directus-template-cli 0.5.0-beta.12 → 0.5.0-beta.13

package/README.md

@@ -5,13 +5,9 @@ A CLI tool to make applying or extracting Directus "templates" a little easier..
 **Notes:**
 
 - This is a beta release. It is recommended for use on POC, demo, or greenfield projects only. When applying templates, you should always backup your project/database before applying a template.
-
 - ⚠️ Known issues with using MySQL currently. We highly recommend using PostgreSQL or SQLite for your database provider. If you're using PostgreSQL in production, we recommend using PostgreSQL in local development as well.
 - If you are extracting or applying from a remote source, the script can take quite a while depending on the "size" of your instance (how many collections, how many items in each collection, number and size of assets, etc). The script applies a strict rate limit of 10 requests per second using bottleneck.
-
-Breaking Changes in v0.5.0
-
-- The CLI is now compatible with Directus 11. If you need to apply or extract to an instance of Directus 10, you can use v0.4.0 of the CLI. `npx directus-template-cli@0.4 extract` or `npx directus-template-cli@0.4 apply`.
+- As of v0.5.0, the CLI is compatible with Directus 11 and up. If you need to apply or extract to an instance of Directus 10, you can use v0.4.0 of the CLI. `npx directus-template-cli@0.4 extract` or `npx directus-template-cli@0.4 apply`.
 
 Using the @latest tag ensures you're receiving the latest version of the packaged templates with the CLI. You can review [the specific versions on NPM](https://www.npmjs.com/package/directus-template-cli) and use @{version} syntax to apply the templates included with that version.
 
@@ -25,7 +21,7 @@ Using the @latest tag ensures you're receiving the latest version of the package
 4. Run the following command on the terminal and follow the prompts.
 
 ```
-$ npx directus-template-cli@latest apply
+npx directus-template-cli@latest apply
 ```
 
 You can choose from our community maintained templates or you can also choose a template from a local directory or a public GitHub repository.
@@ -33,13 +29,13 @@ You can choose from our community maintained templates or you can also choose a
 
 ### Programmatic Mode
 
-For CI/CD pipelines or automated scripts, you can use the programmatic mode:
+By default, the CLI will run in interactive mode. For CI/CD pipelines or automated scripts, you can use the programmatic mode:
 
 
 Using a token:
 
 ```
-$ npx directus-template-cli@latest apply -p --directusUrl="http://localhost:8055" --directusToken="admin-token-here" --templateLocation="./my-template" --templateType="local"
+npx directus-template-cli@latest apply -p --directusUrl="http://localhost:8055" --directusToken="admin-token-here" --templateLocation="./my-template" --templateType="local"
 ```
 
 Using email/password:
@@ -62,7 +58,7 @@ Available flags for programmatic mode:
 - `--userEmail`: Email for Directus authentication (required if not using token)
 - `--userPassword`: Password for Directus authentication (required if not using token)
 - `--templateLocation`: Location of the template to apply (required)
-- `--templateType`: Type of template to apply. Options: community, local, github (required)
+- `--templateType`: Type of template to apply. Options: community, local, github. Defaults to `local`.
 - `--partial`: Enable partial template application
 - `--content`: Load Content (data)
 - `--dashboards`: Load Dashboards
@@ -77,7 +73,7 @@ Available flags for programmatic mode:
 When using `--partial`, you can also use `--no` flags to exclude specific components from being applied. For example:
 
 ```
-$ npx directus-template-cli@latest apply -p --directusUrl="http://localhost:8055" --userEmail="admin@example.com" --userPassword="your-password" --templateLocation="./my-template" --templateType="local" --partial --no-content --no-users
+npx directus-template-cli@latest apply -p --directusUrl="http://localhost:8055" --userEmail="admin@example.com" --userPassword="your-password" --templateLocation="./my-template" --templateType="local" --partial --no-content --no-users
 ```
 
 This command will apply the template but exclude content and users. Available `--no` flags include:
@@ -109,13 +105,43 @@ When applying templates, certain components have dependencies on others. Here ar
 When using the `--partial` flag, keep these dependencies in mind. For example:
 
 ```
-$ npx directus-template-cli@latest apply -p --directusUrl="http://localhost:8055" --directusToken="admin-token-here" --templateLocation="./my-template" --templateType="local" --partial --users
+npx directus-template-cli@latest apply -p --directusUrl="http://localhost:8055" --directusToken="admin-token-here" --templateLocation="./my-template" --templateType="local" --partial --users
 ```
 
 This command will automatically include `--permissions` and `--schema` along with `--users`, even if not explicitly specified.
 
 If you use `--no-` flags, be cautious about excluding dependencies. For instance, using `--no-schema` while including `--content` may lead to errors or incomplete application of the template.
 
+#### Using Environment Variables
+
+You can also pass flags as environment variables. This can be useful for CI/CD pipelines or when you want to avoid exposing sensitive information in command-line arguments. Here are the available environment variables:
+
+- `TARGET_DIRECTUS_URL`: Equivalent to `--directusUrl`
+- `TARGET_DIRECTUS_TOKEN`: Equivalent to `--directusToken`
+- `TARGET_DIRECTUS_EMAIL`: Equivalent to `--userEmail`
+- `TARGET_DIRECTUS_PASSWORD`: Equivalent to `--userPassword`
+- `TEMPLATE_LOCATION`: Equivalent to `--templateLocation`
+- `TEMPLATE_TYPE`: Equivalent to `--templateType`
+-
+
+### Existing Data
+
+You can apply a template to an existing Directus instance. This is nice because you can have smaller templates that you can "compose" for various use cases. The CLI tries to be smart about existing items in the target Directus instance. But mileage may vary depending on the size and complexity of the template and the existing instance.
+
+**System Collections**
+
+In most of the system collections (collections,roles, permissions, etc.), if an item with the same identifier already exists, it will be typically be SKIPPED vs overwritten.
+
+Exceptions:
+
+- directus_settings: The CLI attempts to merge the template's project settings with the existing settings in the target instance. Using the existing settings as a base and updating them with the values from the template. This should prevent overwriting branding, themes, and other customizations.
+
+**Your Collections:**
+
+For data in your own user-created collections, if an item has the same primary key, the data will be overwritten with the incoming data from the template.
+
+---
+
 ## Extracting a Template
 
 The CLI can also extract a template from a Directus instance so that it can be applied to other instances.
@@ -133,7 +159,7 @@ npx directus-template-cli@latest extract
 
 ### Programmatic Mode
 
-For CI/CD pipelines or automated scripts, you can use the programmatic mode:
+By default, the CLI will run in interactive mode. For CI/CD pipelines or automated scripts, you can use the programmatic mode:
 
 Using a token:
 
@@ -156,12 +182,20 @@ Available flags for programmatic mode:
 - `--templateLocation`: Directory to extract the template to (required)
 - `--templateName`: Name of the template (required)
 
+#### Using Environment Variables
+
+Similar to the Apply command, you can use environment variables for the Extract command as well:
+
+- `SOURCE_DIRECTUS_URL`: Equivalent to `--directusUrl`
+- `SOURCE_DIRECTUS_TOKEN`: Equivalent to `--directusToken`
+- `SOURCE_DIRECTUS_EMAIL`: Equivalent to `--userEmail`
+- `SOURCE_DIRECTUS_PASSWORD`: Equivalent to `--userPassword`
+- `TEMPLATE_LOCATION`: Equivalent to `--templateLocation`
+
 ## Logs
 
 The Directus Template CLI logs information to a file in the `.directus-template-cli/logs` directory.
 
-### Log Generation
-
 Logs are automatically generated for each run of the CLI. Here's how the logging system works:
    - A new log file is created for each CLI run.
    - Log files are stored in the `.directus-template-cli/logs` directory within your current working directory.

package/dist/commands/apply.d.ts

@@ -21,17 +21,31 @@ export default class ApplyCommand extends Command {
         userPassword: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         users: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
+    /**
+     * MAIN
+     * Run the command
+     * @returns {Promise<void>} - Returns nothing
+     */
     run(): Promise<void>;
-    private checkAtLeastOneFlagEnabled;
-    private handleDependencies;
-    private handlePartialFlags;
-    private initializeDirectusApi;
-    private redirectToDirectusPlus;
+    /**
+     * INTERACTIVE
+     * Run the command in interactive mode
+     * @param flags - The ApplyFlags
+     * @returns {Promise<void>} - Returns nothing
+     */
     private runInteractive;
+    /**
+     * PROGRAMMATIC
+     * Run the command in programmatic mode
+     * @param flags - The ApplyFlags
+     * @returns {Promise<void>} - Returns nothing
+     */
     private runProgrammatic;
+    /**
+     * INTERACTIVE
+     * Select a local template from the given directory
+     * @param localTemplateDir - The local template directory path
+     * @returns {Promise<Template>} - Returns the selected template
+     */
     private selectLocalTemplate;
-    private setAllFlagsTrue;
-    private setSpecificFlags;
-    private validateFlags;
-    private validateProgrammaticFlags;
 }

package/dist/commands/apply.js

@@ -1,85 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const sdk_1 = require("@directus/sdk");
 const core_1 = require("@oclif/core");
 const inquirer = tslib_1.__importStar(require("inquirer"));
+const customFlags = tslib_1.__importStar(require("../flags/common"));
 const constants_1 = require("../lib/constants");
+const apply_flags_1 = require("../lib/load/apply-flags");
 const index_js_1 = tslib_1.__importDefault(require("../lib/load/index.js"));
-const sdk_2 = require("../lib/sdk");
 const auth_1 = require("../lib/utils/auth");
 const catch_error_1 = tslib_1.__importDefault(require("../lib/utils/catch-error"));
 const get_template_1 = require("../lib/utils/get-template");
 const logger_1 = require("../lib/utils/logger");
 const open_url_1 = tslib_1.__importDefault(require("../lib/utils/open-url"));
 class ApplyCommand extends core_1.Command {
-    // MAIN FUNCTION
+    /**
+     * MAIN
+     * Run the command
+     * @returns {Promise<void>} - Returns nothing
+     */
     async run() {
         const { flags } = await this.parse(ApplyCommand);
         const typedFlags = flags;
         await (typedFlags.programmatic ? this.runProgrammatic(typedFlags) : this.runInteractive(typedFlags));
     }
-    checkAtLeastOneFlagEnabled(validatedFlags, loadFlags) {
-        const enabledFlags = loadFlags.filter(flag => validatedFlags[flag] === true);
-        if (enabledFlags.length === 0) {
-            core_1.ux.error('When using --partial, at least one component must be loaded.');
-        }
-    }
-    handleDependencies(validatedFlags, flags) {
-        if (validatedFlags.content) {
-            validatedFlags.schema = true;
-            validatedFlags.files = true;
-            if (!flags.schema || !flags.files) {
-                core_1.ux.warn('Content loading requires schema and files. Enabling schema and files flags.');
-            }
-        }
-        if (validatedFlags.users) {
-            validatedFlags.permissions = true;
-            if (!flags.permissions) {
-                core_1.ux.warn('User loading requires permissions. Enabling permissions flag.');
-            }
-        }
-    }
-    handlePartialFlags(validatedFlags, flags, loadFlags) {
-        const explicitlyEnabledFlags = loadFlags.filter(flag => flags[flag] === true);
-        const explicitlyDisabledFlags = loadFlags.filter(flag => flags[flag] === false);
-        if (explicitlyEnabledFlags.length > 0) {
-            this.setSpecificFlags(validatedFlags, loadFlags, explicitlyEnabledFlags, true);
-        }
-        else if (explicitlyDisabledFlags.length > 0) {
-            this.setSpecificFlags(validatedFlags, loadFlags, explicitlyDisabledFlags, false);
-        }
-        else {
-            this.setAllFlagsTrue(validatedFlags, loadFlags);
-        }
-        this.handleDependencies(validatedFlags, flags);
-        this.checkAtLeastOneFlagEnabled(validatedFlags, loadFlags);
-    }
-    async initializeDirectusApi(flags) {
-        sdk_2.api.initialize(flags.directusUrl);
-        try {
-            if (flags.directusToken) {
-                await sdk_2.api.loginWithToken(flags.directusToken);
-            }
-            else if (flags.userEmail && flags.userPassword) {
-                await sdk_2.api.login(flags.userEmail, flags.userPassword);
-            }
-            const response = await sdk_2.api.client.request((0, sdk_1.readMe)());
-            core_1.ux.log(`-- Logged in as ${response.first_name} ${response.last_name}`);
-        }
-        catch {
-            (0, catch_error_1.default)('-- Unable to authenticate with the provided credentials. Please check your credentials.', {
-                fatal: true,
-            });
-        }
-    }
-    redirectToDirectusPlus() {
-        (0, open_url_1.default)('https://directus.io/plus?utm_source=directus-template-cli&utm_content=apply-command');
-        core_1.ux.log('Redirecting to Directus website.');
-        core_1.ux.exit(0);
-    }
+    /**
+     * INTERACTIVE
+     * Run the command in interactive mode
+     * @param flags - The ApplyFlags
+     * @returns {Promise<void>} - Returns nothing
+     */
     async runInteractive(flags) {
-        const validatedFlags = this.validateFlags(flags);
+        const validatedFlags = (0, apply_flags_1.validateInteractiveFlags)(flags);
         core_1.ux.styledHeader(core_1.ux.colorize(constants_1.DIRECTUS_PURPLE, 'Directus Template CLI - Apply'));
         const templateType = await inquirer.prompt([
             {
@@ -120,7 +71,9 @@ class ApplyCommand extends core_1.Command {
                 break;
             }
             case 'directus-plus': {
-                this.redirectToDirectusPlus();
+                (0, open_url_1.default)('https://directus.io/plus?utm_source=directus-template-cli&utm_content=apply-command');
+                core_1.ux.log('Redirecting to Directus website.');
+                core_1.ux.exit(0);
             }
         }
         core_1.ux.log(`You selected ${core_1.ux.colorize(constants_1.DIRECTUS_PINK, template.templateName)}`);
@@ -151,7 +104,7 @@ class ApplyCommand extends core_1.Command {
             const userPassword = await core_1.ux.prompt('What is your password?');
             validatedFlags.userPassword = userPassword;
         }
-        await this.initializeDirectusApi(validatedFlags);
+        await (0, auth_1.initializeDirectusApi)(validatedFlags);
         if (template) {
             core_1.ux.styledHeader(core_1.ux.colorize(constants_1.DIRECTUS_PURPLE, `Applying template - ${template.templateName} to ${directusUrl}`));
             await (0, index_js_1.default)(template.directoryPath, validatedFlags);
@@ -161,8 +114,14 @@ class ApplyCommand extends core_1.Command {
             core_1.ux.exit(0);
         }
     }
+    /**
+     * PROGRAMMATIC
+     * Run the command in programmatic mode
+     * @param flags - The ApplyFlags
+     * @returns {Promise<void>} - Returns nothing
+     */
     async runProgrammatic(flags) {
-        const validatedFlags = this.validateFlags(flags);
+        const validatedFlags = (0, apply_flags_1.validateProgrammaticFlags)(flags);
         let template;
         switch (validatedFlags.templateType) {
             case 'community': {
@@ -184,7 +143,7 @@ class ApplyCommand extends core_1.Command {
                 });
             }
         }
-        await this.initializeDirectusApi(validatedFlags);
+        await (0, auth_1.initializeDirectusApi)(validatedFlags);
         const logMessage = `Applying template - ${template.templateName} to ${validatedFlags.directusUrl}`;
         core_1.ux.styledHeader(logMessage);
         logger_1.logger.log('info', logMessage);
@@ -194,6 +153,12 @@ class ApplyCommand extends core_1.Command {
         core_1.ux.info('Template applied successfully.');
         core_1.ux.exit(0);
     }
+    /**
+     * INTERACTIVE
+     * Select a local template from the given directory
+     * @param localTemplateDir - The local template directory path
+     * @returns {Promise<Template>} - Returns the selected template
+     */
     async selectLocalTemplate(localTemplateDir) {
         try {
             const templates = await (0, get_template_1.getInteractiveLocalTemplate)(localTemplateDir);
@@ -219,55 +184,6 @@ class ApplyCommand extends core_1.Command {
             }
         }
     }
-    setAllFlagsTrue(flags, loadFlags) {
-        for (const flag of loadFlags) {
-            flags[flag] = true;
-        }
-        return flags;
-    }
-    setSpecificFlags(flags, allFlags, specificFlags, value) {
-        for (const flag of allFlags) {
-            flags[flag] = specificFlags.includes(flag) === value;
-        }
-    }
-    validateFlags(flags) {
-        this.validateProgrammaticFlags(flags);
-        const loadFlags = [
-            'content',
-            'dashboards',
-            'extensions',
-            'files',
-            'flows',
-            'permissions',
-            'schema',
-            'settings',
-            'users',
-        ];
-        const validatedFlags = { ...flags };
-        if (flags.programmatic && !flags.partial) {
-            return this.setAllFlagsTrue(validatedFlags, loadFlags);
-        }
-        if (flags.partial) {
-            this.handlePartialFlags(validatedFlags, flags, loadFlags);
-        }
-        else {
-            this.setAllFlagsTrue(validatedFlags, loadFlags);
-        }
-        return validatedFlags;
-    }
-    validateProgrammaticFlags(flags) {
-        if (!flags.programmatic)
-            return;
-        if (!flags.directusUrl) {
-            core_1.ux.error('Directus URL is required for programmatic mode.');
-        }
-        if (!flags.directusToken && (!flags.userEmail || !flags.userPassword)) {
-            core_1.ux.error('Either Directus token or email and password are required for programmatic mode.');
-        }
-        if (!flags.templateLocation) {
-            core_1.ux.error('Template location is required for programmatic mode.');
-        }
-    }
 }
 ApplyCommand.description = 'Apply a template to a blank Directus instance.';
 ApplyCommand.examples = [
@@ -286,15 +202,8 @@ ApplyCommand.flags = {
         default: undefined,
         description: 'Load Dashboards (dashboards, panels)',
     }),
-    directusToken: core_1.Flags.string({
-        description: 'Token to use for the Directus instance',
-        env: 'TARGET_DIRECTUS_TOKEN',
-        exclusive: ['userEmail', 'userPassword'],
-    }),
-    directusUrl: core_1.Flags.string({
-        description: 'URL of the Directus instance to apply the template to',
-        env: 'TARGET_DIRECTUS_URL',
-    }),
+    directusToken: customFlags.directusToken,
+    directusUrl: customFlags.directusUrl,
     extensions: core_1.Flags.boolean({
         allowNo: true,
         default: undefined,
@@ -321,12 +230,7 @@ ApplyCommand.flags = {
         description: 'Loads permissions data. Collections include: directus_roles, directus_policies, directus_access, directus_permissions.',
         summary: 'Load permissions (roles, policies, access, permissions)',
     }),
-    programmatic: core_1.Flags.boolean({
-        char: 'p',
-        default: false,
-        description: 'Run in programmatic mode (non-interactive) for use cases such as CI/CD pipelines.',
-        summary: 'Run in programmatic mode',
-    }),
+    programmatic: customFlags.programmatic,
     schema: core_1.Flags.boolean({
         allowNo: true,
         default: undefined,
@@ -337,11 +241,7 @@ ApplyCommand.flags = {
         default: undefined,
         description: 'Load settings (project settings, translations, presets)',
     }),
-    templateLocation: core_1.Flags.string({
-        dependsOn: ['programmatic', 'templateType'],
-        description: 'Location of the template to apply',
-        env: 'TEMPLATE_LOCATION',
-    }),
+    templateLocation: customFlags.templateLocation,
     templateType: core_1.Flags.string({
         default: 'local',
         dependsOn: ['programmatic'],
@@ -350,18 +250,8 @@ ApplyCommand.flags = {
         options: ['community', 'local', 'github'],
         summary: 'Type of template to apply. Options: community, local, github.',
     }),
-    userEmail: core_1.Flags.string({
-        dependsOn: ['userPassword'],
-        description: 'Email for Directus authentication',
-        env: 'TARGET_DIRECTUS_EMAIL',
-        exclusive: ['directusToken'],
-    }),
-    userPassword: core_1.Flags.string({
-        dependsOn: ['userEmail'],
-        description: 'Password for Directus authentication',
-        env: 'TARGET_DIRECTUS_PASSWORD',
-        exclusive: ['directusToken'],
-    }),
+    userEmail: customFlags.userEmail,
+    userPassword: customFlags.userPassword,
     users: core_1.Flags.boolean({
         allowNo: true,
         default: undefined,

package/dist/commands/extract.d.ts

@@ -11,10 +11,36 @@ export default class ExtractCommand extends Command {
         userEmail: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         userPassword: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
+    /**
+     * Main run method for the ExtractCommand
+     * @returns {Promise<void>} - Returns nothing
+     */
     run(): Promise<void>;
+    /**
+     * Extracts the template to the specified directory
+     * @param {string} templateName - The name of the template to extract
+     * @param {string} directory - The directory to extract the template to
+     * @param {ExtractFlags} flags - The command flags
+     * @returns {Promise<void>} - Returns nothing
+     */
     private extractTemplate;
-    private initializeDirectusApi;
+    /**
+     * Runs the interactive mode for template extraction
+     * @param {ExtractFlags} flags - The command flags
+     * @returns {Promise<void>} - Returns nothing
+     */
     private runInteractive;
+    /**
+     * Runs the programmatic mode for template extraction
+     * @param {ExtractFlags} flags - The command flags
+     * @returns {Promise<void>} - Returns nothing
+     */
     private runProgrammatic;
+    /**
+     * Validates the flags for programmatic mode
+     * @param {ExtractFlags} flags - The command flags to validate
+     * @throws {Error} If required flags are missing
+     * @returns {void}
+     */
     private validateProgrammaticFlags;
 }

package/dist/commands/extract.js

@@ -1,24 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const sdk_1 = require("@directus/sdk");
 const core_1 = require("@oclif/core");
 const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
 const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
 const node_path_1 = tslib_1.__importDefault(require("node:path"));
 const slugify_1 = tslib_1.__importDefault(require("slugify"));
+const customFlags = tslib_1.__importStar(require("../flags/common"));
 const constants_1 = require("../lib/constants");
 const extract_1 = tslib_1.__importDefault(require("../lib/extract/"));
-const sdk_2 = require("../lib/sdk");
 const auth_1 = require("../lib/utils/auth");
 const catch_error_1 = tslib_1.__importDefault(require("../lib/utils/catch-error"));
 const template_defaults_1 = require("../lib/utils/template-defaults");
 class ExtractCommand extends core_1.Command {
+    /**
+     * Main run method for the ExtractCommand
+     * @returns {Promise<void>} - Returns nothing
+     */
     async run() {
         const { flags } = await this.parse(ExtractCommand);
         const typedFlags = flags;
         await (typedFlags.programmatic ? this.runProgrammatic(typedFlags) : this.runInteractive(typedFlags));
     }
+    /**
+     * Extracts the template to the specified directory
+     * @param {string} templateName - The name of the template to extract
+     * @param {string} directory - The directory to extract the template to
+     * @param {ExtractFlags} flags - The command flags
+     * @returns {Promise<void>} - Returns nothing
+     */
     async extractTemplate(templateName, directory, flags) {
         try {
             if (!node_fs_1.default.existsSync(directory)) {
@@ -32,7 +42,11 @@ class ExtractCommand extends core_1.Command {
             node_fs_1.default.writeFileSync(readmePath, readmeContent);
         }
         catch (error) {
-            core_1.ux.error(`Failed to create directory or write files: ${error.message}`);
+            (0, catch_error_1.default)(error, {
+                context: { function: 'extractTemplate' },
+                fatal: true,
+                logToFile: true,
+            });
         }
         core_1.ux.log(constants_1.SEPARATOR);
         core_1.ux.action.start(`Extracting template - ${core_1.ux.colorize(constants_1.DIRECTUS_PINK, templateName)} from ${core_1.ux.colorize(constants_1.DIRECTUS_PINK, flags.directusUrl)} to ${core_1.ux.colorize(constants_1.DIRECTUS_PINK, directory)}`);
@@ -42,24 +56,11 @@ class ExtractCommand extends core_1.Command {
         core_1.ux.log('Template extracted successfully.');
         this.exit(0);
     }
-    async initializeDirectusApi(flags) {
-        sdk_2.api.initialize(flags.directusUrl);
-        try {
-            if (flags.directusToken) {
-                await sdk_2.api.loginWithToken(flags.directusToken);
-            }
-            else if (flags.userEmail && flags.userPassword) {
-                await sdk_2.api.login(flags.userEmail, flags.userPassword);
-            }
-            const response = await sdk_2.api.client.request((0, sdk_1.readMe)());
-            core_1.ux.log(`-- Logged in as ${response.first_name} ${response.last_name}`);
-        }
-        catch {
-            (0, catch_error_1.default)('-- Unable to authenticate with the provided credentials. Please check your credentials.', {
-                fatal: true,
-            });
-        }
-    }
+    /**
+     * Runs the interactive mode for template extraction
+     * @param {ExtractFlags} flags - The command flags
+     * @returns {Promise<void>} - Returns nothing
+     */
     async runInteractive(flags) {
         core_1.ux.styledHeader(core_1.ux.colorize(constants_1.DIRECTUS_PURPLE, 'Directus Template CLI - Extract'));
         const templateName = await core_1.ux.prompt('What is the name of the template you would like to extract?');
@@ -91,23 +92,28 @@ class ExtractCommand extends core_1.Command {
             flags.userPassword = await core_1.ux.prompt('What is your password?', { type: 'hide' });
         }
         core_1.ux.log(constants_1.SEPARATOR);
-        await this.initializeDirectusApi(flags);
+        await (0, auth_1.initializeDirectusApi)(flags);
         await this.extractTemplate(templateName, directory, flags);
     }
+    /**
+     * Runs the programmatic mode for template extraction
+     * @param {ExtractFlags} flags - The command flags
+     * @returns {Promise<void>} - Returns nothing
+     */
     async runProgrammatic(flags) {
         this.validateProgrammaticFlags(flags);
         const { templateLocation, templateName } = flags;
-        await this.initializeDirectusApi(flags);
+        await (0, auth_1.initializeDirectusApi)(flags);
         await this.extractTemplate(templateName, templateLocation, flags);
     }
+    /**
+     * Validates the flags for programmatic mode
+     * @param {ExtractFlags} flags - The command flags to validate
+     * @throws {Error} If required flags are missing
+     * @returns {void}
+     */
     validateProgrammaticFlags(flags) {
-        if (!flags.directusUrl) {
-            core_1.ux.error('Directus URL is required for programmatic mode.');
-        }
-        // We need either a token or email/password
-        if (!flags.directusToken && (!flags.userEmail || !flags.userPassword)) {
-            core_1.ux.error('Either Directus token or email and password are required for programmatic mode.');
-        }
+        (0, auth_1.validateAuthFlags)(flags);
         if (!flags.templateLocation) {
             core_1.ux.error('Template location is required for programmatic mode.');
         }
@@ -122,42 +128,12 @@ ExtractCommand.examples = [
     '$ directus-template-cli extract -p --templateName="My Template" --templateLocation="./my-template" --directusToken="admin-token-here" --directusUrl="http://localhost:8055"',
 ];
 ExtractCommand.flags = {
-    directusToken: core_1.Flags.string({
-        description: 'Token to use for the Directus instance',
-        env: 'SOURCE_DIRECTUS_TOKEN',
-        exclusive: ['userEmail', 'userPassword'],
-    }),
-    directusUrl: core_1.Flags.string({
-        description: 'URL of the Directus instance to extract the template from',
-        env: 'SOURCE_DIRECTUS_URL',
-    }),
-    programmatic: core_1.Flags.boolean({
-        char: 'p',
-        default: false,
-        description: 'Run in programmatic mode (non-interactive) for use cases such as CI/CD pipelines.',
-        summary: 'Run in programmatic mode',
-    }),
-    templateLocation: core_1.Flags.string({
-        dependsOn: ['programmatic'],
-        description: 'Directory to extract the template to',
-        env: 'TEMPLATE_LOCATION',
-    }),
-    templateName: core_1.Flags.string({
-        dependsOn: ['programmatic'],
-        description: 'Name of the template',
-        env: 'TEMPLATE_NAME',
-    }),
-    userEmail: core_1.Flags.string({
-        dependsOn: ['userPassword'],
-        description: 'Email for Directus authentication',
-        env: 'SOURCE_DIRECTUS_EMAIL',
-        exclusive: ['directusToken'],
-    }),
-    userPassword: core_1.Flags.string({
-        dependsOn: ['userEmail'],
-        description: 'Password for Directus authentication',
-        env: 'SOURCE_DIRECTUS_PASSWORD',
-        exclusive: ['directusToken'],
-    }),
+    directusToken: customFlags.directusToken,
+    directusUrl: customFlags.directusUrl,
+    programmatic: customFlags.programmatic,
+    templateLocation: customFlags.templateLocation,
+    templateName: customFlags.templateName,
+    userEmail: customFlags.userEmail,
+    userPassword: customFlags.userPassword,
 };
 exports.default = ExtractCommand;

package/dist/flags/common.d.ts

@@ -0,0 +1,7 @@
+export declare const directusToken: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+export declare const directusUrl: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+export declare const userEmail: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+export declare const userPassword: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+export declare const programmatic: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+export declare const templateLocation: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+export declare const templateName: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/flags/common.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateName = exports.templateLocation = exports.programmatic = exports.userPassword = exports.userEmail = exports.directusUrl = exports.directusToken = void 0;
+const core_1 = require("@oclif/core");
+exports.directusToken = core_1.Flags.string({
+    description: 'Token to use for the Directus instance',
+    env: 'DIRECTUS_TOKEN',
+    exclusive: ['userEmail', 'userPassword'],
+});
+exports.directusUrl = core_1.Flags.string({
+    description: 'URL of the Directus instance',
+    env: 'DIRECTUS_URL',
+});
+exports.userEmail = core_1.Flags.string({
+    dependsOn: ['userPassword'],
+    description: 'Email for Directus authentication',
+    env: 'DIRECTUS_EMAIL',
+    exclusive: ['directusToken'],
+});
+exports.userPassword = core_1.Flags.string({
+    dependsOn: ['userEmail'],
+    description: 'Password for Directus authentication',
+    env: 'DIRECTUS_PASSWORD',
+    exclusive: ['directusToken'],
+});
+exports.programmatic = core_1.Flags.boolean({
+    char: 'p',
+    default: false,
+    description: 'Run in programmatic mode (non-interactive) for use cases such as CI/CD pipelines.',
+    summary: 'Run in programmatic mode',
+});
+exports.templateLocation = core_1.Flags.string({
+    dependsOn: ['programmatic'],
+    description: 'Location of the template',
+    env: 'TEMPLATE_LOCATION',
+});
+exports.templateName = core_1.Flags.string({
+    dependsOn: ['programmatic'],
+    description: 'Name of the template',
+    env: 'TEMPLATE_NAME',
+});

package/dist/lib/load/apply-flags.d.ts

@@ -0,0 +1,22 @@
+export interface ApplyFlags {
+    content: boolean;
+    dashboards: boolean;
+    directusToken: string;
+    directusUrl: string;
+    extensions: boolean;
+    files: boolean;
+    flows: boolean;
+    partial: boolean;
+    permissions: boolean;
+    programmatic: boolean;
+    schema: boolean;
+    settings: boolean;
+    templateLocation: string;
+    templateType: 'community' | 'github' | 'local';
+    userEmail: string;
+    userPassword: string;
+    users: boolean;
+}
+export declare const loadFlags: readonly ["content", "dashboards", "extensions", "files", "flows", "permissions", "schema", "settings", "users"];
+export declare function validateProgrammaticFlags(flags: ApplyFlags): ApplyFlags;
+export declare function validateInteractiveFlags(flags: ApplyFlags): ApplyFlags;

package/dist/lib/load/apply-flags.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInteractiveFlags = exports.validateProgrammaticFlags = exports.loadFlags = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const catch_error_1 = tslib_1.__importDefault(require("../utils/catch-error"));
+exports.loadFlags = [
+    'content',
+    'dashboards',
+    'extensions',
+    'files',
+    'flows',
+    'permissions',
+    'schema',
+    'settings',
+    'users',
+];
+function validateProgrammaticFlags(flags) {
+    const { directusToken, directusUrl, templateLocation, userEmail, userPassword } = flags;
+    if (!directusUrl)
+        core_1.ux.error('Directus URL is required for programmatic mode.');
+    if (!directusToken && (!userEmail || !userPassword))
+        core_1.ux.error('Either Directus token or email and password are required for programmatic mode.');
+    if (!templateLocation)
+        core_1.ux.error('Template location is required for programmatic mode.');
+    return flags.partial ? handlePartialFlags(flags) : setAllFlagsTrue(flags);
+}
+exports.validateProgrammaticFlags = validateProgrammaticFlags;
+function validateInteractiveFlags(flags) {
+    return flags.partial ? handlePartialFlags(flags) : setAllFlagsTrue(flags);
+}
+exports.validateInteractiveFlags = validateInteractiveFlags;
+function handlePartialFlags(flags) {
+    const enabledFlags = exports.loadFlags.filter(flag => flags[flag] === true);
+    const disabledFlags = exports.loadFlags.filter(flag => flags[flag] === false);
+    if (enabledFlags.length > 0) {
+        for (const flag of exports.loadFlags)
+            flags[flag] = enabledFlags.includes(flag);
+    }
+    else if (disabledFlags.length > 0) {
+        for (const flag of exports.loadFlags)
+            flags[flag] = !disabledFlags.includes(flag);
+    }
+    else {
+        setAllFlagsTrue(flags);
+    }
+    handleDependencies(flags);
+    if (!exports.loadFlags.some(flag => flags[flag])) {
+        (0, catch_error_1.default)(new Error('When using --partial, at least one component must be loaded.'), { fatal: true });
+    }
+    return flags;
+}
+function handleDependencies(flags) {
+    if (flags.content && (!flags.schema || !flags.files)) {
+        flags.schema = flags.files = true;
+        core_1.ux.warn('Content loading requires schema and files. Enabling schema and files flags.');
+    }
+    if (flags.users && !flags.permissions) {
+        flags.permissions = true;
+        core_1.ux.warn('User loading requires permissions. Enabling permissions flag.');
+    }
+}
+function setAllFlagsTrue(flags) {
+    for (const flag of exports.loadFlags)
+        flags[flag] = true;
+    return flags;
+}

package/dist/lib/sdk.d.ts

@@ -1,6 +1,19 @@
 import type { AuthenticationClient, RestClient } from '@directus/sdk';
 export interface Schema {
 }
+export declare class DirectusError extends Error {
+    errors: Array<{
+        extensions?: Record<string, unknown>;
+        message: string;
+    }>;
+    headers: Headers;
+    message: string;
+    response: Response;
+    status: number;
+    constructor(response: Response);
+    formatError(): string;
+    parseErrors(): Promise<void>;
+}
 declare class Api {
     client: (RestClient<Schema> & AuthenticationClient<Schema>) | undefined;
     private authData;
@@ -12,6 +25,7 @@ declare class Api {
     loginWithToken(token: string): Promise<void>;
     logout(): Promise<void>;
     refreshToken(): Promise<void>;
+    private enhancedFetch;
 }
 declare const api: Api;
 export { api };

package/dist/lib/sdk.js

@@ -1,17 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.api = void 0;
+exports.api = exports.DirectusError = void 0;
 const tslib_1 = require("tslib");
 const sdk_1 = require("@directus/sdk");
 const bottleneck_1 = tslib_1.__importDefault(require("bottleneck"));
+class DirectusError extends Error {
+    constructor(response) {
+        super(response.statusText);
+        this.name = 'DirectusError';
+        this.headers = response.headers;
+        this.status = response.status;
+        this.response = response;
+        this.errors = [];
+        this.message = response.statusText;
+    }
+    formatError() {
+        if (this.errors.length === 0) {
+            return `Directus Error: ${this.message} (Status: ${this.status})`;
+        }
+        const { extensions, message } = this.errors[0];
+        let formattedError = `Directus Error: ${message.trim()} (Status: ${this.status})`;
+        if (extensions) {
+            formattedError += ` ${JSON.stringify(extensions)}`;
+        }
+        return formattedError;
+    }
+    async parseErrors() {
+        try {
+            const data = await this.response.json();
+            if (data && Array.isArray(data.errors)) {
+                this.errors = data.errors;
+                this.message = this.formatError();
+            }
+        }
+        catch {
+            // If parsing fails, keep the errors array empty
+        }
+    }
+}
+exports.DirectusError = DirectusError;
 class Api {
     constructor() {
         this.authData = null;
         this.limiter = new bottleneck_1.default({
             maxConcurrent: 10,
-            minTime: 100,
-            retryCount: 3,
-            retryDelay: 3000,
+            minTime: 100, // Ensure at least 100ms between requests
+            reservoir: 50, // Reservoir to handle the default rate limiter of 50 requests per second
+            reservoirRefreshAmount: 50,
+            reservoirRefreshInterval: 1000, // Refill 50 requests every 1 second
+            retryCount: 3, // Retry a maximum of 3 times
+        });
+        this.limiter.on('failed', async (error, jobInfo) => {
+            var _a;
+            if (error instanceof DirectusError) {
+                const retryAfter = (_a = error.headers) === null || _a === void 0 ? void 0 : _a.get('Retry-After');
+                const statusCode = error.status;
+                if (statusCode === 429) {
+                    const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : 60000;
+                    console.log(`-- Rate limited. Retrying after ${delay}ms`);
+                    return delay;
+                }
+                if (statusCode === 503) {
+                    const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : 5000;
+                    console.log(`-- Server under pressure. Retrying after ${delay}ms`);
+                    return delay;
+                }
+                if (statusCode === 400) {
+                    return;
+                }
+            }
+            // For other errors, use exponential backoff, but only if we haven't exceeded retryCount
+            if (jobInfo.retryCount < 3) {
+                const delay = Math.min(1000 * 2 ** jobInfo.retryCount, 30000);
+                console.log(`Request failed. Retrying after ${delay}ms`);
+                return delay;
+            }
+            console.log('Max retries reached, not retrying further');
+        });
+        this.limiter.on('retry', (error, jobInfo) => {
+            console.log(`Retrying job (attempt ${jobInfo.retryCount + 1})`);
+        });
+        this.limiter.on('depleted', empty => {
+            if (empty) {
+                console.log('Rate limit quota depleted. Requests will be queued.');
+            }
         });
     }
     getToken() {
@@ -21,7 +93,7 @@ class Api {
     initialize(url) {
         this.client = (0, sdk_1.createDirectus)(url, {
             globals: {
-                fetch: (...args) => this.limiter.schedule(() => fetch(...args)),
+                fetch: this.limiter.wrap(this.enhancedFetch),
             },
         })
             .with((0, sdk_1.rest)())
@@ -60,6 +132,15 @@ class Api {
         }
         await this.client.refresh();
     }
+    async enhancedFetch(...args) {
+        const response = await fetch(...args);
+        if (!response.ok) {
+            const error = new DirectusError(response);
+            await error.parseErrors();
+            throw error;
+        }
+        return response;
+    }
 }
 const api = new Api();
 exports.api = api;

package/dist/lib/utils/auth.d.ts

@@ -1,2 +1,28 @@
+interface AuthFlags {
+    directusToken?: string;
+    directusUrl: string;
+    userEmail?: string;
+    userPassword?: string;
+}
+/**
+ * Get the Directus URL from the user
+ * @returns The Directus URL
+ */
 export declare function getDirectusUrl(): Promise<string>;
+/**
+ * Get the Directus token from the user
+ * @param directusUrl - The Directus URL
+ * @returns The Directus token
+ */
 export declare function getDirectusToken(directusUrl: string): Promise<string>;
+/**
+   * Initialize the Directus API with the provided flags
+   * @param flags - The validated ApplyFlags
+   */
+export declare function initializeDirectusApi(flags: AuthFlags): Promise<void>;
+/**
+ * Validate the authentication flags
+ * @param flags - The AuthFlags
+ */
+export declare function validateAuthFlags(flags: AuthFlags): void;
+export {};

package/dist/lib/utils/auth.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDirectusToken = exports.getDirectusUrl = void 0;
+exports.validateAuthFlags = exports.initializeDirectusApi = exports.getDirectusToken = exports.getDirectusUrl = void 0;
 const tslib_1 = require("tslib");
 const sdk_1 = require("@directus/sdk");
 const core_1 = require("@oclif/core");
 const sdk_2 = require("../sdk");
 const catch_error_1 = tslib_1.__importDefault(require("./catch-error"));
 const validate_url_1 = tslib_1.__importDefault(require("./validate-url"));
+/**
+ * Get the Directus URL from the user
+ * @returns The Directus URL
+ */
 async function getDirectusUrl() {
     const directusUrl = await core_1.ux.prompt('What is your Directus URL?', { default: 'http://localhost:8055' });
     // Validate URL
@@ -18,9 +22,14 @@ async function getDirectusUrl() {
     return directusUrl;
 }
 exports.getDirectusUrl = getDirectusUrl;
+/**
+ * Get the Directus token from the user
+ * @param directusUrl - The Directus URL
+ * @returns The Directus token
+ */
 async function getDirectusToken(directusUrl) {
     const directusToken = await core_1.ux.prompt('What is your Directus Admin Token?');
-    // Validate token
+    // Validate token by fetching the user
     try {
         await sdk_2.api.loginWithToken(directusToken);
         const response = await sdk_2.api.client.request((0, sdk_1.readMe)());
@@ -38,3 +47,39 @@ async function getDirectusToken(directusUrl) {
     }
 }
 exports.getDirectusToken = getDirectusToken;
+/**
+   * Initialize the Directus API with the provided flags
+   * @param flags - The validated ApplyFlags
+   */
+async function initializeDirectusApi(flags) {
+    sdk_2.api.initialize(flags.directusUrl);
+    try {
+        if (flags.directusToken) {
+            await sdk_2.api.loginWithToken(flags.directusToken);
+        }
+        else if (flags.userEmail && flags.userPassword) {
+            await sdk_2.api.login(flags.userEmail, flags.userPassword);
+        }
+        const response = await sdk_2.api.client.request((0, sdk_1.readMe)());
+        core_1.ux.log(`-- Logged in as ${response.first_name} ${response.last_name}`);
+    }
+    catch {
+        (0, catch_error_1.default)('-- Unable to authenticate with the provided credentials. Please check your credentials.', {
+            fatal: true,
+        });
+    }
+}
+exports.initializeDirectusApi = initializeDirectusApi;
+/**
+ * Validate the authentication flags
+ * @param flags - The AuthFlags
+ */
+function validateAuthFlags(flags) {
+    if (!flags.directusUrl) {
+        core_1.ux.error('Directus URL is required.');
+    }
+    if (!flags.directusToken && (!flags.userEmail || !flags.userPassword)) {
+        core_1.ux.error('Either Directus token or email and password are required.');
+    }
+}
+exports.validateAuthFlags = validateAuthFlags;

package/dist/lib/utils/catch-error.d.ts

@@ -1,6 +1,19 @@
-interface Options {
+/**
+ * Options for configuring the error handler behavior.
+ */
+interface ErrorHandlerOptions {
+    /** Additional context to be included in the error log. */
     context?: Record<string, any>;
+    /** If true, the error will be treated as fatal and the process will exit. */
     fatal?: boolean;
+    /** If true, the error will be logged to a file. */
+    logToFile?: boolean;
 }
-export default function catchError(error: unknown, options?: Options, logToFile?: boolean): void;
+/**
+ * Handles errors by formatting them and optionally logging to console and file.
+ * @param error - The error to be handled.
+ * @param options - Configuration options for error handling.
+ * @returns void
+ */
+export default function catchError(error: unknown, options?: ErrorHandlerOptions): void;
 export {};

package/dist/lib/utils/catch-error.js

@@ -1,35 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const logger_1 = require("./logger");
-function catchError(error, options = {}, logToFile = true) {
-    const errorMessage = isDirectusError(error) ? formatDirectusError(error)
-        : (error instanceof Error ? formatGenericError(error)
-            : `${JSON.stringify(error)}`);
-    const contextString = options.context
-        ? Object.entries(options.context)
-            .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-            .join(', ') : '';
+const sdk_1 = require("../sdk");
+const logger_1 = require("../utils/logger");
+/**
+ * Handles errors by formatting them and optionally logging to console and file.
+ * @param error - The error to be handled.
+ * @param options - Configuration options for error handling.
+ * @returns void
+ */
+function catchError(error, options = {}) {
+    const { context = {}, fatal = false, logToFile = true } = options;
+    let errorMessage;
+    if (error instanceof sdk_1.DirectusError) {
+        errorMessage = error.message;
+    }
+    else if (error instanceof Error) {
+        errorMessage = `Error: ${error.message}`;
+    }
+    else {
+        errorMessage = `Unknown error: ${JSON.stringify(error)}`;
+    }
+    // Format the error message with context if provided
     const formattedMessage = [
         errorMessage,
-        contextString && `Context: ${contextString}`,
+        Object.keys(context).length > 0 && `Context: ${JSON.stringify(context)}`,
     ].filter(Boolean).join('\n');
-    options.fatal ? core_1.ux.error(formattedMessage) : core_1.ux.warn(formattedMessage);
+    // Log the error message to the console with the appropriate color
+    if (fatal) {
+        // ux.error exits the process with a non-zero code
+        core_1.ux.error(formattedMessage);
+    }
+    else {
+        core_1.ux.warn(formattedMessage);
+    }
     if (logToFile) {
-        logger_1.logger.log('error', errorMessage, options.context);
+        logger_1.logger.log('error', errorMessage, context);
     }
 }
 exports.default = catchError;
-function isDirectusError(error) {
-    // @ts-ignore
-    return error && Array.isArray(error.errors) && error.errors.length > 0;
-}
-function formatDirectusError(error) {
-    var _a;
-    const status = ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) || 'Unknown';
-    const { extensions, message } = error.errors[0];
-    return `Directus Error: ${message.trim()}${extensions ? ` (${JSON.stringify(extensions)})` : ''} (Status: ${status})`;
-}
-function formatGenericError(error) {
-    return `Error: ${error.message}`;
-}

package/oclif.manifest.json

@@ -24,7 +24,7 @@
         },
         "directusToken": {
           "description": "Token to use for the Directus instance",
-          "env": "TARGET_DIRECTUS_TOKEN",
+          "env": "DIRECTUS_TOKEN",
           "exclusive": [
             "userEmail",
             "userPassword"
@@ -35,8 +35,8 @@
           "type": "option"
         },
         "directusUrl": {
-          "description": "URL of the Directus instance to apply the template to",
-          "env": "TARGET_DIRECTUS_URL",
+          "description": "URL of the Directus instance",
+          "env": "DIRECTUS_URL",
           "name": "directusUrl",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -99,10 +99,9 @@
         },
         "templateLocation": {
           "dependsOn": [
-            "programmatic",
-            "templateType"
+            "programmatic"
           ],
-          "description": "Location of the template to apply",
+          "description": "Location of the template",
           "env": "TEMPLATE_LOCATION",
           "name": "templateLocation",
           "hasDynamicHelp": false,
@@ -132,7 +131,7 @@
             "userPassword"
           ],
           "description": "Email for Directus authentication",
-          "env": "TARGET_DIRECTUS_EMAIL",
+          "env": "DIRECTUS_EMAIL",
           "exclusive": [
             "directusToken"
           ],
@@ -146,7 +145,7 @@
             "userEmail"
           ],
           "description": "Password for Directus authentication",
-          "env": "TARGET_DIRECTUS_PASSWORD",
+          "env": "DIRECTUS_PASSWORD",
           "exclusive": [
             "directusToken"
           ],
@@ -188,7 +187,7 @@
       "flags": {
         "directusToken": {
           "description": "Token to use for the Directus instance",
-          "env": "SOURCE_DIRECTUS_TOKEN",
+          "env": "DIRECTUS_TOKEN",
           "exclusive": [
             "userEmail",
             "userPassword"
@@ -199,8 +198,8 @@
           "type": "option"
         },
         "directusUrl": {
-          "description": "URL of the Directus instance to extract the template from",
-          "env": "SOURCE_DIRECTUS_URL",
+          "description": "URL of the Directus instance",
+          "env": "DIRECTUS_URL",
           "name": "directusUrl",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -218,7 +217,7 @@
           "dependsOn": [
             "programmatic"
           ],
-          "description": "Directory to extract the template to",
+          "description": "Location of the template",
           "env": "TEMPLATE_LOCATION",
           "name": "templateLocation",
           "hasDynamicHelp": false,
@@ -241,7 +240,7 @@
             "userPassword"
           ],
           "description": "Email for Directus authentication",
-          "env": "SOURCE_DIRECTUS_EMAIL",
+          "env": "DIRECTUS_EMAIL",
           "exclusive": [
             "directusToken"
           ],
@@ -255,7 +254,7 @@
             "userEmail"
           ],
           "description": "Password for Directus authentication",
-          "env": "SOURCE_DIRECTUS_PASSWORD",
+          "env": "DIRECTUS_PASSWORD",
           "exclusive": [
             "directusToken"
           ],
@@ -281,5 +280,5 @@
       ]
     }
   },
-  "version": "0.5.0-beta.12"
+  "version": "0.5.0-beta.13"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directus-template-cli",
-  "version": "0.5.0-beta.12",
+  "version": "0.5.0-beta.13",
   "description": "CLI Utility for applying templates to a Directus instance.",
   "author": "bryantgillespie @bryantgillespie",
   "bin": {

package/dist/lib/interfaces.d.ts

@@ -1,8 +0,0 @@
-export interface Diff {
-    diff: {
-        collections: any[];
-        fields: any[];
-        relations: any[];
-    };
-    hash: string;
-}

package/dist/lib/interfaces.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });