@strapi/strapi 4.10.0-beta.1 → 4.10.1-experimental.0

package/lib/commands/{configurationDump.js → actions/configuration/dump/action.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 const fs = require('fs');
-const strapi = require('../index');
+const strapi = require('../../../../index');
 
 const CHUNK_SIZE = 100;
 

package/lib/commands/actions/configuration/dump/command.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { getLocalScript } = require('../../../utils/helpers');
+
+/**
+ * `$ strapi configuration:dump`
+ * @param {import('../../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('configuration:dump')
+    .alias('config:dump')
+    .description('Dump configurations of your application')
+    .option('-f, --file <file>', 'Output file, default output is stdout')
+    .option('-p, --pretty', 'Format the output JSON with indentation and line breaks', false)
+    .action(getLocalScript('configuration/dump'));
+};

package/lib/commands/{configurationRestore.js → actions/configuration/restore/action.js}

@@ -3,7 +3,7 @@
 const fs = require('fs');
 const _ = require('lodash');
 
-const strapi = require('../index');
+const strapi = require('../../../../index');
 
 /**
  * Will restore configurations. It reads from a file or stdin

package/lib/commands/actions/configuration/restore/command.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { getLocalScript } = require('../../../utils/helpers');
+
+/**
+ * `$ strapi configuration:restore`
+ * @param {import('../../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('configuration:restore')
+    .alias('config:restore')
+    .description('Restore configurations of your application')
+    .option('-f, --file <file>', 'Input file, default input is stdin')
+    .option('-s, --strategy <strategy>', 'Strategy name, one of: "replace", "merge", "keep"')
+    .action(getLocalScript('configuration/restore'));
+};

package/lib/commands/{console.js → actions/console/action.js}

@@ -2,7 +2,7 @@
 
 const REPL = require('repl');
 
-const strapi = require('../index');
+const strapi = require('../../../index');
 
 /**
  * `$ strapi console`
@@ -14,7 +14,7 @@ module.exports = async () => {
   app.start().then(() => {
     const repl = REPL.start(app.config.info.name + ' > ' || 'strapi > '); // eslint-disable-line prefer-template
 
-    repl.on('exit', function (err) {
+    repl.on('exit', (err) => {
       if (err) {
         app.log.error(err);
         process.exit(1);

package/lib/commands/actions/console/command.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { getLocalScript } = require('../../utils/helpers');
+
+/**
+ * `$ strapi console`
+ * @param {import('../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('console')
+    .description('Open the Strapi framework console')
+    .action(getLocalScript('console'));
+};

package/lib/commands/{content-types/list.js → actions/content-types/list/action.js}

@@ -3,9 +3,9 @@
 const CLITable = require('cli-table3');
 const chalk = require('chalk');
 
-const strapi = require('../../index');
+const strapi = require('../../../../index');
 
-module.exports = async function () {
+module.exports = async () => {
   const appContext = await strapi.compile();
   const app = await strapi(appContext).register();
 

package/lib/commands/actions/content-types/list/command.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { getLocalScript } = require('../../../utils/helpers');
+
+/**
+ * `$ strapi content-types:list`
+ * @param {import('../../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('content-types:list')
+    .description('List all the application content-types')
+    .action(getLocalScript('content-types/list'));
+};

package/lib/commands/{controllers/list.js → actions/controllers/list/action.js}

@@ -3,9 +3,9 @@
 const CLITable = require('cli-table3');
 const chalk = require('chalk');
 
-const strapi = require('../../index');
+const strapi = require('../../../../index');
 
-module.exports = async function () {
+module.exports = async () => {
   const appContext = await strapi.compile();
   const app = await strapi(appContext).register();
 

package/lib/commands/actions/controllers/list/command.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { getLocalScript } = require('../../../utils/helpers');
+
+/**
+ * `$ strapi controllers:list`
+ * @param {import('../../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('controllers:list')
+    .description('List all the application controllers')
+    .action(getLocalScript('controllers/list'));
+};

package/lib/commands/{develop.js → actions/develop/action.js}

@@ -9,9 +9,9 @@ const { getOr } = require('lodash/fp');
 const { joinBy } = require('@strapi/utils');
 const tsUtils = require('@strapi/typescript-utils');
 
-const loadConfiguration = require('../core/app-configuration');
-const strapi = require('../index');
-const { buildTypeScript, buildAdmin } = require('./builders');
+const loadConfiguration = require('../../../core/app-configuration');
+const strapi = require('../../../index');
+const { buildTypeScript, buildAdmin } = require('../../builders');
 
 /**
  * `$ strapi develop`

package/lib/commands/actions/develop/command.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { getLocalScript } = require('../../utils/helpers');
+
+/**
+ * `$ strapi develop`
+ * @param {import('../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('develop')
+    .alias('dev')
+    .option('--no-build', 'Disable build')
+    .option('--watch-admin', 'Enable watch', false)
+    .option('--polling', 'Watch for file changes in network directories', false)
+    .option('--browser <name>', 'Open the browser', true)
+    .description('Start your Strapi application in development mode')
+    .action(getLocalScript('develop'));
+};

package/lib/commands/actions/export/__tests__/export.test.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const { expectExit } = require('../../../__tests__/commands.test.utils');
+
+describe('Export', () => {
+  const defaultFileName = 'defaultFilename';
+
+  jest.mock('fs-extra', () => ({
+    pathExists: jest.fn(() => Promise.resolve(true)),
+  }));
+
+  const mockDataTransfer = {
+    file: {
+      providers: {
+        createLocalFileDestinationProvider: jest.fn().mockReturnValue({ name: 'testDest' }),
+      },
+    },
+    strapi: {
+      providers: {
+        createLocalStrapiSourceProvider: jest.fn().mockReturnValue({ name: 'testSource' }),
+      },
+    },
+    engine: {
+      ...jest.requireActual('@strapi/data-transfer').engine,
+      errors: {},
+      createTransferEngine() {
+        return {
+          transfer: jest.fn(() => {
+            return {
+              engine: {},
+              destination: {
+                file: {
+                  path: 'path',
+                },
+              },
+            };
+          }),
+          progress: {
+            on: jest.fn(),
+            stream: {
+              on: jest.fn(),
+            },
+          },
+          sourceProvider: { name: 'testSource' },
+          destinationProvider: { name: 'testDestination' },
+          diagnostics: {
+            on: jest.fn().mockReturnThis(),
+            onDiagnostic: jest.fn().mockReturnThis(),
+          },
+        };
+      },
+    },
+  };
+
+  jest.mock('@strapi/data-transfer', () => mockDataTransfer);
+
+  // command utils
+  const mockUtils = {
+    getTransferTelemetryPayload: jest.fn().mockReturnValue({}),
+    loadersFactory: jest.fn().mockReturnValue({ updateLoader: jest.fn() }),
+    formatDiagnostic: jest.fn(),
+    createStrapiInstance() {
+      return {
+        telemetry: {
+          send: jest.fn(),
+        },
+      };
+    },
+    getDefaultExportName: jest.fn(() => defaultFileName),
+    buildTransferTable: jest.fn(() => {
+      return {
+        toString() {
+          return 'table';
+        },
+      };
+    }),
+    exitMessageText: jest.fn(),
+  };
+  jest.mock(
+    '../../../utils/data-transfer.js',
+    () => {
+      return mockUtils;
+    },
+    { virtual: true }
+  );
+
+  // console spies
+  jest.spyOn(console, 'log').mockImplementation(() => {});
+  jest.spyOn(console, 'warn').mockImplementation(() => {});
+  jest.spyOn(console, 'info').mockImplementation(() => {});
+  jest.spyOn(console, 'error').mockImplementation(() => {});
+
+  // Now that everything is mocked, load the 'export' command
+  const exportAction = require('../action');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('uses path provided by user', async () => {
+    const filename = 'test';
+
+    await expectExit(0, async () => {
+      await exportAction({ file: filename });
+    });
+
+    expect(console.error).not.toHaveBeenCalled();
+    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        file: { path: filename },
+      })
+    );
+    expect(mockUtils.getDefaultExportName).not.toHaveBeenCalled();
+  });
+
+  it('uses default path if not provided by user', async () => {
+    await expectExit(0, async () => {
+      await exportAction({});
+    });
+
+    expect(mockUtils.getDefaultExportName).toHaveBeenCalledTimes(1);
+    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        file: { path: defaultFileName },
+      })
+    );
+  });
+
+  it('encrypts the output file if specified', async () => {
+    const encrypt = true;
+    await expectExit(0, async () => {
+      await exportAction({ encrypt });
+    });
+
+    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        encryption: { enabled: encrypt },
+      })
+    );
+  });
+
+  it('encrypts the output file with the given key', async () => {
+    const key = 'secret-key';
+    const encrypt = true;
+    await expectExit(0, async () => {
+      await exportAction({ encrypt, key });
+    });
+
+    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        encryption: { enabled: encrypt, key },
+      })
+    );
+  });
+
+  it('uses compress option', async () => {
+    await expectExit(0, async () => {
+      await exportAction({ compress: false });
+    });
+
+    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        compression: { enabled: false },
+      })
+    );
+    await expectExit(0, async () => {
+      await exportAction({ compress: true });
+    });
+    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        compression: { enabled: true },
+      })
+    );
+  });
+});

package/lib/commands/{transfer/export.js → actions/export/action.js}

@@ -25,8 +25,9 @@ const {
   exitMessageText,
   abortTransfer,
   getTransferTelemetryPayload,
-} = require('./utils');
-const { exitWith } = require('../utils/helpers');
+} = require('../../utils/data-transfer');
+const { exitWith } = require('../../utils/helpers');
+
 /**
  * @typedef ExportCommandOptions Options given to the CLI import command
  *

package/lib/commands/actions/export/command.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const { Option } = require('commander');
+const {
+  excludeOption,
+  onlyOption,
+  throttleOption,
+  validateExcludeOnly,
+} = require('../../utils/data-transfer');
+const { promptEncryptionKey } = require('../../utils/commander');
+const { getLocalScript } = require('../../utils/helpers');
+
+/**
+ * `$ strapi export`
+ * @param {import('../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('export')
+    .description('Export data from Strapi to file')
+    .allowExcessArguments(false)
+    .addOption(
+      new Option('--no-encrypt', `Disables 'aes-128-ecb' encryption of the output file`).default(
+        true
+      )
+    )
+    .addOption(
+      new Option('--no-compress', 'Disables gzip compression of output file').default(true)
+    )
+    .addOption(
+      new Option(
+        '-k, --key <string>',
+        'Provide encryption key in command instead of using the prompt'
+      )
+    )
+    .addOption(
+      new Option('-f, --file <file>', 'name to use for exported file (without extensions)')
+    )
+    .addOption(excludeOption)
+    .addOption(onlyOption)
+    .addOption(throttleOption)
+    .hook('preAction', validateExcludeOnly)
+    .hook('preAction', promptEncryptionKey)
+    .action(getLocalScript('export'));
+};

package/lib/commands/actions/generate/command.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const { assertCwdContainsStrapiProject } = require('../../utils/helpers');
+
+/**
+ * `$ strapi generate`
+ * @param {import('../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command, argv }) => {
+  command
+    .command('generate')
+    .description('Launch the interactive API generator')
+    .action(() => {
+      assertCwdContainsStrapiProject('generate');
+      argv.splice(2, 1);
+      require('@strapi/generators').runCLI();
+    });
+};

package/lib/commands/{hooks/list.js → actions/hooks/list/action.js}

@@ -3,9 +3,9 @@
 const CLITable = require('cli-table3');
 const chalk = require('chalk');
 
-const strapi = require('../../index');
+const strapi = require('../../../../index');
 
-module.exports = async function () {
+module.exports = async () => {
   const appContext = await strapi.compile();
   const app = await strapi(appContext).register();
 

package/lib/commands/actions/hooks/list/command.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { getLocalScript } = require('../../../utils/helpers');
+
+/**
+ * `$ strapi hooks:list`
+ * @param {import('../../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('hooks:list')
+    .description('List all the application hooks')
+    .action(getLocalScript('hooks/list'));
+};

package/lib/commands/actions/import/__tests__/import.test.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const {
+  strapi: {
+    providers: { DEFAULT_CONFLICT_STRATEGY },
+  },
+  engine: { DEFAULT_SCHEMA_STRATEGY, DEFAULT_VERSION_STRATEGY },
+} = require('@strapi/data-transfer');
+
+const { expectExit } = require('../../../__tests__/commands.test.utils');
+
+const createTransferEngine = jest.fn(() => {
+  return {
+    transfer: jest.fn(() => {
+      return {
+        engine: {},
+      };
+    }),
+    progress: {
+      on: jest.fn(),
+      stream: {
+        on: jest.fn(),
+      },
+    },
+    sourceProvider: { name: 'testFileSource', type: 'source', getMetadata: jest.fn() },
+    destinationProvider: {
+      name: 'testStrapiDest',
+      type: 'destination',
+      getMetadata: jest.fn(),
+    },
+    diagnostics: {
+      on: jest.fn().mockReturnThis(),
+      onDiagnostic: jest.fn().mockReturnThis(),
+    },
+  };
+});
+
+describe('Import', () => {
+  const mockDataTransfer = {
+    file: {
+      providers: {
+        createLocalFileSourceProvider: jest
+          .fn()
+          .mockReturnValue({ name: 'testFileSource', type: 'source', getMetadata: jest.fn() }),
+      },
+    },
+    strapi: {
+      providers: {
+        DEFAULT_CONFLICT_STRATEGY,
+        createLocalStrapiDestinationProvider: jest
+          .fn()
+          .mockReturnValue({ name: 'testStrapiDest', type: 'destination', getMetadata: jest.fn() }),
+      },
+    },
+    engine: {
+      ...jest.requireActual('@strapi/data-transfer').engine,
+      DEFAULT_SCHEMA_STRATEGY,
+      DEFAULT_VERSION_STRATEGY,
+      createTransferEngine,
+    },
+  };
+
+  jest.mock('@strapi/data-transfer', () => mockDataTransfer);
+
+  // command utils
+  const mockUtils = {
+    getTransferTelemetryPayload: jest.fn().mockReturnValue({}),
+    loadersFactory: jest.fn().mockReturnValue({ updateLoader: jest.fn() }),
+    formatDiagnostic: jest.fn(),
+    createStrapiInstance: jest.fn().mockReturnValue({
+      telemetry: {
+        send: jest.fn(),
+      },
+      destroy: jest.fn(),
+    }),
+    buildTransferTable: jest.fn(() => {
+      return {
+        toString() {
+          return 'table';
+        },
+      };
+    }),
+    exitMessageText: jest.fn(),
+  };
+  jest.mock(
+    '../../../utils/data-transfer.js',
+    () => {
+      return mockUtils;
+    },
+    { virtual: true }
+  );
+
+  // console spies
+  jest.spyOn(console, 'log').mockImplementation(() => {});
+  jest.spyOn(console, 'warn').mockImplementation(() => {});
+  jest.spyOn(console, 'info').mockImplementation(() => {});
+  jest.spyOn(console, 'error').mockImplementation(() => {});
+
+  // Now that everything is mocked, load the 'import' command
+  const importAction = require('../action');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('creates providers with correct options ', async () => {
+    const options = {
+      file: 'test.tar.gz.enc',
+      decrypt: true,
+      decompress: true,
+      exclude: [],
+      only: [],
+    };
+
+    await expectExit(0, async () => {
+      await importAction(options);
+    });
+
+    // strapi options
+    expect(
+      mockDataTransfer.strapi.providers.createLocalStrapiDestinationProvider
+    ).toHaveBeenCalledWith(expect.objectContaining({ strategy: DEFAULT_CONFLICT_STRATEGY }));
+
+    // file options
+    expect(mockDataTransfer.file.providers.createLocalFileSourceProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        file: { path: 'test.tar.gz.enc' },
+        encryption: { enabled: options.decrypt },
+        compression: { enabled: options.decompress },
+      })
+    );
+
+    // engine options
+    expect(mockDataTransfer.engine.createTransferEngine).toHaveBeenCalledWith(
+      expect.objectContaining({ name: 'testFileSource' }),
+      expect.objectContaining({ name: 'testStrapiDest' }),
+      expect.objectContaining({
+        schemaStrategy: DEFAULT_SCHEMA_STRATEGY,
+        versionStrategy: DEFAULT_VERSION_STRATEGY,
+      })
+    );
+  });
+});

package/lib/commands/{transfer/import.js → actions/import/action.js}

@@ -21,8 +21,8 @@ const {
   exitMessageText,
   abortTransfer,
   getTransferTelemetryPayload,
-} = require('./utils');
-const { exitWith } = require('../utils/helpers');
+} = require('../../utils/data-transfer');
+const { exitWith } = require('../../utils/helpers');
 
 /**
  * @typedef {import('@strapi/data-transfer/src/file/providers').ILocalFileSourceProviderOptions} ILocalFileSourceProviderOptions