@directus/extensions-sdk 9.20.3 → 9.21.0

package/dist/esm/cli/commands/add.js

@@ -0,0 +1,236 @@
+import path from 'path';
+import chalk from 'chalk';
+import fse from 'fs-extra';
+import inquirer from 'inquirer';
+import { log } from '../utils/logger';
+import { isIn, isTypeIn, validateExtensionManifest } from '@directus/shared/utils';
+import { pathToRelativeUrl } from '@directus/shared/utils/node';
+import { EXTENSION_LANGUAGES, EXTENSION_NAME_REGEX, EXTENSION_PKG_KEY, EXTENSION_TYPES, HYBRID_EXTENSION_TYPES, } from '@directus/shared/constants';
+import { getLanguageFromPath, isLanguage, languageToShort } from '../utils/languages';
+import getExtensionDevDeps from './helpers/get-extension-dev-deps';
+import execa from 'execa';
+import ora from 'ora';
+import copyTemplate from './helpers/copy-template';
+import detectJsonIndent from '../utils/detect-json-indent';
+import getPackageManager from '../utils/get-package-manager';
+export default async function add() {
+    var _a, _b;
+    const extensionPath = process.cwd();
+    const packagePath = path.resolve('package.json');
+    if (!(await fse.pathExists(packagePath))) {
+        log(`Current directory is not a valid package.`, 'error');
+        process.exit(1);
+    }
+    const extensionManifestFile = await fse.readFile(packagePath, 'utf8');
+    const extensionManifest = JSON.parse(extensionManifestFile);
+    const indent = detectJsonIndent(extensionManifestFile);
+    if (!validateExtensionManifest(extensionManifest)) {
+        log(`Current directory is not a valid Directus extension.`, 'error');
+        process.exit(1);
+    }
+    const extensionOptions = extensionManifest[EXTENSION_PKG_KEY];
+    if (extensionOptions.type === 'pack') {
+        log(`Adding entries to extensions with type ${chalk.bold('pack')} is not currently supported.`, 'error');
+        process.exit(1);
+    }
+    const sourceExists = await fse.pathExists(path.resolve('src'));
+    if (extensionOptions.type === 'bundle') {
+        const { type, name, language, alternativeSource } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Choose the extension type',
+                choices: EXTENSION_TYPES,
+            },
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Choose a name for the entry',
+                validate: (name) => (name.length === 0 ? 'Entry name can not be empty.' : true),
+            },
+            {
+                type: 'list',
+                name: 'language',
+                message: 'Choose the language to use',
+                choices: EXTENSION_LANGUAGES,
+            },
+            {
+                type: 'input',
+                name: 'alternativeSource',
+                message: 'Specify the path to the extension source',
+                when: !sourceExists && extensionOptions.entries.length > 0,
+            },
+        ]);
+        const spinner = ora(chalk.bold('Modifying Directus extension...')).start();
+        const source = alternativeSource !== null && alternativeSource !== void 0 ? alternativeSource : 'src';
+        const sourcePath = path.resolve(source, name);
+        await fse.ensureDir(sourcePath);
+        await copyTemplate(type, extensionPath, sourcePath, language);
+        const newEntries = [
+            ...extensionOptions.entries,
+            isIn(type, HYBRID_EXTENSION_TYPES)
+                ? {
+                    type,
+                    name,
+                    source: {
+                        app: `${pathToRelativeUrl(source)}/${name}/app.${languageToShort(language)}`,
+                        api: `${pathToRelativeUrl(source)}/${name}/api.${languageToShort(language)}`,
+                    },
+                }
+                : {
+                    type,
+                    name,
+                    source: `${pathToRelativeUrl(source)}/${name}/index.${languageToShort(language)}`,
+                },
+        ];
+        const newExtensionOptions = { ...extensionOptions, entries: newEntries };
+        const newExtensionManifest = {
+            ...extensionManifest,
+            [EXTENSION_PKG_KEY]: newExtensionOptions,
+            devDependencies: await getExtensionDevDeps(newEntries.map((entry) => entry.type), getLanguageFromEntries(newEntries)),
+        };
+        await fse.writeJSON(packagePath, newExtensionManifest, { spaces: indent !== null && indent !== void 0 ? indent : '\t' });
+        const packageManager = getPackageManager();
+        await execa(packageManager, ['install'], { cwd: extensionPath });
+        spinner.succeed(chalk.bold('Done'));
+    }
+    else {
+        const { proceed } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'proceed',
+                message: 'This will convert your extension to a bundle. Do you want to proceed?',
+            },
+        ]);
+        if (!proceed) {
+            log(`Extension has not been modified.`, 'info');
+            process.exit(1);
+        }
+        const oldName = (_b = (_a = extensionManifest.name.match(EXTENSION_NAME_REGEX)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : extensionManifest.name;
+        const { type, name, language, convertName, extensionName, alternativeSource } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Choose the extension type',
+                choices: EXTENSION_TYPES,
+            },
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Choose a name for the entry',
+                validate: (name) => (name.length === 0 ? 'Entry name can not be empty.' : true),
+            },
+            {
+                type: 'list',
+                name: 'language',
+                message: 'Choose the language to use',
+                choices: EXTENSION_LANGUAGES,
+            },
+            {
+                type: 'input',
+                name: 'convertName',
+                message: 'Choose a name for the extension that is converted to an entry',
+                default: oldName,
+                validate: (name) => (name.length === 0 ? 'Entry name can not be empty.' : true),
+            },
+            {
+                type: 'input',
+                name: 'extensionName',
+                message: 'Choose a name for the extension',
+                default: ({ convertName }) => (convertName !== oldName ? oldName : null),
+                validate: (name) => (name.length === 0 ? 'Extension name can not be empty.' : true),
+            },
+            {
+                type: 'input',
+                name: 'alternativeSource',
+                message: 'Specify the path to the extension source',
+                when: !sourceExists,
+            },
+        ]);
+        const spinner = ora(chalk.bold('Modifying Directus extension...')).start();
+        const source = alternativeSource !== null && alternativeSource !== void 0 ? alternativeSource : 'src';
+        const convertSourcePath = path.resolve(source, convertName);
+        const entrySourcePath = path.resolve(source, name);
+        const convertFiles = await fse.readdir(source);
+        await Promise.all(convertFiles.map((file) => fse.move(path.resolve(source, file), path.join(convertSourcePath, file))));
+        await fse.ensureDir(entrySourcePath);
+        await copyTemplate(type, extensionPath, entrySourcePath, language);
+        const toConvertSourceUrl = (entrypoint) => path.posix.join(pathToRelativeUrl(source), convertName, path.posix.relative(source, entrypoint));
+        const entries = [
+            isTypeIn(extensionOptions, HYBRID_EXTENSION_TYPES)
+                ? {
+                    type: extensionOptions.type,
+                    name: convertName,
+                    source: {
+                        app: toConvertSourceUrl(extensionOptions.source.app),
+                        api: toConvertSourceUrl(extensionOptions.source.api),
+                    },
+                }
+                : {
+                    type: extensionOptions.type,
+                    name: convertName,
+                    source: toConvertSourceUrl(extensionOptions.source),
+                },
+            isIn(type, HYBRID_EXTENSION_TYPES)
+                ? {
+                    type,
+                    name,
+                    source: {
+                        app: `${pathToRelativeUrl(source)}/${name}/app.${languageToShort(language)}`,
+                        api: `${pathToRelativeUrl(source)}/${name}/api.${languageToShort(language)}`,
+                    },
+                }
+                : {
+                    type,
+                    name,
+                    source: `${pathToRelativeUrl(source)}/${name}/index.${languageToShort(language)}`,
+                },
+        ];
+        const newExtensionOptions = {
+            type: 'bundle',
+            path: { app: 'dist/app.js', api: 'dist/api.js' },
+            entries,
+            host: extensionOptions.host,
+            hidden: extensionOptions.hidden,
+        };
+        const newExtensionManifest = {
+            ...extensionManifest,
+            name: EXTENSION_NAME_REGEX.test(extensionName) ? extensionName : `directus-extension-${extensionName}`,
+            keywords: ['directus', 'directus-extension', `directus-custom-bundle`],
+            [EXTENSION_PKG_KEY]: newExtensionOptions,
+            devDependencies: await getExtensionDevDeps(entries.map((entry) => entry.type), getLanguageFromEntries(entries)),
+        };
+        await fse.writeJSON(packagePath, newExtensionManifest, { spaces: indent !== null && indent !== void 0 ? indent : '\t' });
+        const packageManager = getPackageManager();
+        await execa(packageManager, ['install'], { cwd: extensionPath });
+        spinner.succeed(chalk.bold('Done'));
+    }
+}
+function getLanguageFromEntries(entries) {
+    const languages = new Set();
+    for (const entry of entries) {
+        if (isTypeIn(entry, HYBRID_EXTENSION_TYPES)) {
+            const languageApp = getLanguageFromPath(entry.source.app);
+            const languageApi = getLanguageFromPath(entry.source.api);
+            if (!isLanguage(languageApp)) {
+                log(`App language ${chalk.bold(languageApp)} is not supported.`, 'error');
+                process.exit(1);
+            }
+            if (!isLanguage(languageApi)) {
+                log(`API language ${chalk.bold(languageApi)} is not supported.`, 'error');
+                process.exit(1);
+            }
+            languages.add(languageApp);
+            languages.add(languageApi);
+        }
+        else {
+            const language = getLanguageFromPath(entry.source);
+            if (!isLanguage(language)) {
+                log(`Language ${chalk.bold(language)} is not supported.`, 'error');
+                process.exit(1);
+            }
+            languages.add(language);
+        }
+    }
+    return Array.from(languages);
+}

package/dist/esm/cli/commands/build.d.ts

@@ -1,4 +1,4 @@
-declare type BuildOptions = {
+type BuildOptions = {
     type?: string;
     input?: string;
     output?: string;

package/dist/esm/cli/commands/build.js

@@ -1,22 +1,25 @@
-import path from 'path';
+import { API_SHARED_DEPS, APP_EXTENSION_TYPES, APP_SHARED_DEPS, EXTENSION_PACKAGE_TYPES, EXTENSION_PKG_KEY, HYBRID_EXTENSION_TYPES, } from '@directus/shared/constants';
+import { isIn, isTypeIn, validateExtensionManifest } from '@directus/shared/utils';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import replace from '@rollup/plugin-replace';
+import terser from '@rollup/plugin-terser';
+import virtual from '@rollup/plugin-virtual';
 import chalk from 'chalk';
 import fse from 'fs-extra';
 import ora from 'ora';
+import path from 'path';
 import { rollup, watch as rollupWatch, } from 'rollup';
-import { nodeResolve } from '@rollup/plugin-node-resolve';
-import commonjs from '@rollup/plugin-commonjs';
-import json from '@rollup/plugin-json';
-import replace from '@rollup/plugin-replace';
-import typescript from 'rollup-plugin-typescript2';
-import { terser } from 'rollup-plugin-terser';
 import styles from 'rollup-plugin-styles';
+import typescript from 'rollup-plugin-typescript2';
 import vue from 'rollup-plugin-vue';
-import { EXTENSION_PKG_KEY, EXTENSION_TYPES, APP_SHARED_DEPS, API_SHARED_DEPS, APP_EXTENSION_TYPES, HYBRID_EXTENSION_TYPES, } from '@directus/shared/constants';
-import { isIn, isTypeIn, validateExtensionManifest } from '@directus/shared/utils';
-import { log, clear } from '../utils/logger';
 import { getLanguageFromPath, isLanguage } from '../utils/languages';
-import loadConfig from '../utils/load-config';
-import toObject from '../utils/to-object';
+import { clear, log } from '../utils/logger';
+import tryParseJson from '../utils/try-parse-json';
+import generateBundleEntrypoint from './helpers/generate-bundle-entrypoint';
+import loadConfig from './helpers/load-config';
+import { validateBundleEntriesOption, validateSplitEntrypointOption } from './helpers/validate-cli-options';
 export default async function build(options) {
     var _a, _b, _c;
     const watch = (_a = options.watch) !== null && _a !== void 0 ? _a : false;
@@ -24,24 +27,31 @@ export default async function build(options) {
     const minify = (_c = options.minify) !== null && _c !== void 0 ? _c : false;
     if (!options.type && !options.input && !options.output) {
         const packagePath = path.resolve('package.json');
-        let extensionManifest = {};
         if (!(await fse.pathExists(packagePath))) {
             log(`Current directory is not a valid package.`, 'error');
             process.exit(1);
         }
-        else {
-            extensionManifest = await fse.readJSON(packagePath);
-            if (!validateExtensionManifest(extensionManifest)) {
-                log(`Current directory is not a valid Directus extension.`, 'error');
-                process.exit(1);
-            }
+        const extensionManifest = await fse.readJSON(packagePath);
+        if (!validateExtensionManifest(extensionManifest)) {
+            log(`Current directory is not a valid Directus extension.`, 'error');
+            process.exit(1);
         }
         const extensionOptions = extensionManifest[EXTENSION_PKG_KEY];
-        if (!isTypeIn(extensionOptions, EXTENSION_TYPES)) {
-            log(`Extension type ${chalk.bold(extensionOptions.type)} is not supported. Available extension types: ${EXTENSION_TYPES.map((t) => chalk.bold.magenta(t)).join(', ')}.`, 'error');
+        if (extensionOptions.type === 'pack') {
+            log(`Building extension type ${chalk.bold('pack')} is not currently supported.`, 'error');
             process.exit(1);
         }
-        if (isTypeIn(extensionOptions, HYBRID_EXTENSION_TYPES)) {
+        if (extensionOptions.type === 'bundle') {
+            await buildBundleExtension({
+                entries: extensionOptions.entries,
+                outputApp: extensionOptions.path.app,
+                outputApi: extensionOptions.path.api,
+                watch,
+                sourcemap,
+                minify,
+            });
+        }
+        else if (isTypeIn(extensionOptions, HYBRID_EXTENSION_TYPES)) {
             await buildHybridExtension({
                 inputApp: extensionOptions.source.app,
                 inputApi: extensionOptions.source.api,
@@ -71,8 +81,12 @@ export default async function build(options) {
             log(`Extension type has to be specified using the ${chalk.blue('[-t, --type <type>]')} option.`, 'error');
             process.exit(1);
         }
-        else if (!isIn(type, EXTENSION_TYPES)) {
-            log(`Extension type ${chalk.bold(type)} is not supported. Available extension types: ${EXTENSION_TYPES.map((t) => chalk.bold.magenta(t)).join(', ')}.`, 'error');
+        if (!isIn(type, EXTENSION_PACKAGE_TYPES)) {
+            log(`Extension type ${chalk.bold(type)} is not supported. Available extension types: ${EXTENSION_PACKAGE_TYPES.map((t) => chalk.bold.magenta(t)).join(', ')}.`, 'error');
+            process.exit(1);
+        }
+        if (type === 'pack') {
+            log(`Building extension type ${chalk.bold('pack')} is not currently supported.`, 'error');
             process.exit(1);
         }
         if (!input) {
@@ -83,22 +97,42 @@ export default async function build(options) {
             log(`Extension output file has to be specified using the ${chalk.blue('[-o, --output <file>]')} option.`, 'error');
             process.exit(1);
         }
-        if (isIn(type, HYBRID_EXTENSION_TYPES)) {
-            const inputObject = toObject(input);
-            const outputObject = toObject(output);
-            if (!inputObject || !inputObject.app || !inputObject.api) {
-                log(`Input option needs to be of the format ${chalk.blue('[-i app:<app-entrypoint>,api:<api-entrypoint>]')}.`, 'error');
+        if (type === 'bundle') {
+            const entries = tryParseJson(input);
+            const splitOutput = tryParseJson(output);
+            if (!validateBundleEntriesOption(entries)) {
+                log(`Input option needs to be of the format ${chalk.blue(`[-i '[{"type":"<extension-type>","name":"<extension-name>","source":<entrypoint>}]']`)}.`, 'error');
+                process.exit(1);
+            }
+            if (!validateSplitEntrypointOption(splitOutput)) {
+                log(`Output option needs to be of the format ${chalk.blue(`[-o '{"app":"<app-entrypoint>","api":"<api-entrypoint>"}']`)}.`, 'error');
+                process.exit(1);
+            }
+            await buildBundleExtension({
+                entries,
+                outputApp: splitOutput.app,
+                outputApi: splitOutput.api,
+                watch,
+                sourcemap,
+                minify,
+            });
+        }
+        else if (isIn(type, HYBRID_EXTENSION_TYPES)) {
+            const splitInput = tryParseJson(input);
+            const splitOutput = tryParseJson(output);
+            if (!validateSplitEntrypointOption(splitInput)) {
+                log(`Input option needs to be of the format ${chalk.blue(`[-i '{"app":"<app-entrypoint>","api":"<api-entrypoint>"}']`)}.`, 'error');
                 process.exit(1);
             }
-            if (!outputObject || !outputObject.app || !outputObject.api) {
-                log(`Output option needs to be of the format ${chalk.blue('[-o app:<app-output-file>,api:<api-output-file>]')}.`, 'error');
+            if (!validateSplitEntrypointOption(splitOutput)) {
+                log(`Output option needs to be of the format ${chalk.blue(`[-o '{"app":"<app-entrypoint>","api":"<api-entrypoint>"}']`)}.`, 'error');
                 process.exit(1);
             }
             await buildHybridExtension({
-                inputApp: inputObject.app,
-                inputApi: inputObject.api,
-                outputApp: outputObject.app,
-                outputApi: outputObject.api,
+                inputApp: splitInput.app,
+                inputApi: splitInput.api,
+                outputApp: splitOutput.app,
+                outputApi: splitOutput.api,
                 watch,
                 sourcemap,
                 minify,
@@ -168,7 +202,7 @@ async function buildHybridExtension({ inputApp, inputApi, outputApp, outputApi,
         process.exit(1);
     }
     if (!isLanguage(languageApi)) {
-        log(`API language ${chalk.bold(languageApp)} is not supported.`, 'error');
+        log(`API language ${chalk.bold(languageApi)} is not supported.`, 'error');
         process.exit(1);
     }
     const config = await loadConfig();
@@ -202,6 +236,95 @@ async function buildHybridExtension({ inputApp, inputApi, outputApp, outputApi,
         await buildExtension(rollupOptionsAll);
     }
 }
+async function buildBundleExtension({ entries, outputApp, outputApi, watch, sourcemap, minify, }) {
+    var _a;
+    if (outputApp.length === 0) {
+        log(`App output file can not be empty.`, 'error');
+        process.exit(1);
+    }
+    if (outputApi.length === 0) {
+        log(`API output file can not be empty.`, 'error');
+        process.exit(1);
+    }
+    const languagesApp = new Set();
+    const languagesApi = new Set();
+    for (const entry of entries) {
+        if (isTypeIn(entry, HYBRID_EXTENSION_TYPES)) {
+            const inputApp = entry.source.app;
+            const inputApi = entry.source.api;
+            if (!(await fse.pathExists(inputApp)) || !(await fse.stat(inputApp)).isFile()) {
+                log(`App entrypoint ${chalk.bold(inputApp)} does not exist.`, 'error');
+                process.exit(1);
+            }
+            if (!(await fse.pathExists(inputApi)) || !(await fse.stat(inputApi)).isFile()) {
+                log(`API entrypoint ${chalk.bold(inputApi)} does not exist.`, 'error');
+                process.exit(1);
+            }
+            const languageApp = getLanguageFromPath(inputApp);
+            const languageApi = getLanguageFromPath(inputApi);
+            if (!isLanguage(languageApp)) {
+                log(`App language ${chalk.bold(languageApp)} is not supported.`, 'error');
+                process.exit(1);
+            }
+            if (!isLanguage(languageApi)) {
+                log(`API language ${chalk.bold(languageApi)} is not supported.`, 'error');
+                process.exit(1);
+            }
+            languagesApp.add(languageApp);
+            languagesApi.add(languageApi);
+        }
+        else {
+            const input = entry.source;
+            if (!(await fse.pathExists(input)) || !(await fse.stat(input)).isFile()) {
+                log(`Entrypoint ${chalk.bold(input)} does not exist.`, 'error');
+                process.exit(1);
+            }
+            const language = getLanguageFromPath(input);
+            if (!isLanguage(language)) {
+                log(`Language ${chalk.bold(language)} is not supported.`, 'error');
+                process.exit(1);
+            }
+            if (isIn(entry.type, APP_EXTENSION_TYPES)) {
+                languagesApp.add(language);
+            }
+            else {
+                languagesApi.add(language);
+            }
+        }
+    }
+    const config = await loadConfig();
+    const plugins = (_a = config.plugins) !== null && _a !== void 0 ? _a : [];
+    const entrypointApp = generateBundleEntrypoint('app', entries);
+    const entrypointApi = generateBundleEntrypoint('api', entries);
+    const rollupOptionsApp = getRollupOptions({
+        mode: 'browser',
+        input: { entry: entrypointApp },
+        language: Array.from(languagesApp),
+        sourcemap,
+        minify,
+        plugins,
+    });
+    const rollupOptionsApi = getRollupOptions({
+        mode: 'node',
+        input: { entry: entrypointApi },
+        language: Array.from(languagesApi),
+        sourcemap,
+        minify,
+        plugins,
+    });
+    const rollupOutputOptionsApp = getRollupOutputOptions({ mode: 'browser', output: outputApp, sourcemap });
+    const rollupOutputOptionsApi = getRollupOutputOptions({ mode: 'node', output: outputApi, sourcemap });
+    const rollupOptionsAll = [
+        { rollupOptions: rollupOptionsApp, rollupOutputOptions: rollupOutputOptionsApp },
+        { rollupOptions: rollupOptionsApi, rollupOutputOptions: rollupOutputOptionsApi },
+    ];
+    if (watch) {
+        await watchExtension(rollupOptionsAll);
+    }
+    else {
+        await buildExtension(rollupOptionsAll);
+    }
+}
 async function buildExtension(config) {
     const configs = Array.isArray(config) ? config : [config];
     const spinner = ora(chalk.bold('Building Directus extension...')).start();
@@ -266,13 +389,15 @@ async function watchExtension(config) {
     }
 }
 function getRollupOptions({ mode, input, language, sourcemap, minify, plugins, }) {
+    const languages = Array.isArray(language) ? language : [language];
     if (mode === 'browser') {
         return {
-            input,
+            input: typeof input !== 'string' ? 'entry' : input,
             external: APP_SHARED_DEPS,
             plugins: [
+                typeof input !== 'string' ? virtual(input) : null,
                 vue({ preprocessStyles: true }),
-                language === 'typescript' ? typescript({ check: false }) : null,
+                languages.includes('typescript') ? typescript({ check: false }) : null,
                 styles(),
                 ...plugins,
                 nodeResolve({ browser: true }),
@@ -290,10 +415,11 @@ function getRollupOptions({ mode, input, language, sourcemap, minify, plugins, }
     }
     else {
         return {
-            input,
+            input: typeof input !== 'string' ? 'entry' : input,
             external: API_SHARED_DEPS,
             plugins: [
-                language === 'typescript' ? typescript({ check: false }) : null,
+                typeof input !== 'string' ? virtual(input) : null,
+                languages.includes('typescript') ? typescript({ check: false }) : null,
                 ...plugins,
                 nodeResolve(),
                 commonjs({ sourceMap: sourcemap }),
@@ -322,7 +448,7 @@ function getRollupOutputOptions({ mode, output, sourcemap, }) {
         return {
             file: output,
             format: 'cjs',
-            exports: 'default',
+            exports: 'auto',
             inlineDynamicImports: true,
             sourcemap,
         };

package/dist/esm/cli/commands/create.d.ts

@@ -1,5 +1,5 @@
-declare type CreateOptions = {
-    language: string;
+type CreateOptions = {
+    language?: string;
 };
 export default function create(type: string, name: string, options: CreateOptions): Promise<void>;
 export {};