directus-template-cli 0.6.0-beta.2 → 0.7.0-beta.10

package/dist/lib/utils/animated-bunny.js

@@ -0,0 +1,62 @@
+import chalk from 'chalk';
+import logUpdate from 'log-update';
+import { DIRECTUS_PINK } from '../constants.js';
+export const RANDOM_SAYINGS = [
+    'One does not simply write backends...',
+    'I don\'t always test my code, but when I do, I use production.',
+    'A wild Directus appears!',
+    'Error 418: I\'m a teapot. Just kidding, I\'m Directus and I\'ve got your backend covered.',
+    'I\'ll fix it later. Narrator: They didn\'t fix it later.',
+];
+export async function animatedBunny(customMessage) {
+    const saying = customMessage || RANDOM_SAYINGS[Math.floor(Math.random() * RANDOM_SAYINGS.length)];
+    let typedSaying = '';
+    let blinkState = true;
+    let charIndex = 0;
+    let isCleanedUp = false;
+    const cleanup = () => {
+        if (isCleanedUp)
+            return;
+        isCleanedUp = true;
+        clearInterval(animation);
+        clearInterval(typing);
+        logUpdate.done();
+    };
+    // Ensure cleanup on process exit
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => {
+        cleanup();
+        process.exit(0);
+    });
+    const updateFrame = () => {
+        if (isCleanedUp)
+            return;
+        const eyes = blinkState ? '- -' : 'Õ Õ';
+        const frame = `(\\   /)\n \\\\_//\n ( ${eyes}) ${chalk.dim('')}${chalk.hex(DIRECTUS_PINK).visible(`"${typedSaying}"`)}\nC(")(")`;
+        logUpdate(frame);
+    };
+    const animation = setInterval(() => {
+        blinkState = !blinkState;
+        updateFrame();
+    }, 500);
+    const typing = setInterval(() => {
+        if (charIndex < saying.length) {
+            typedSaying += saying[charIndex];
+            charIndex++;
+            updateFrame();
+        }
+        else {
+            clearInterval(typing);
+        }
+    }, 25);
+    try {
+        // Run the animation for the duration of typing plus 1 second
+        await new Promise(resolve => setTimeout(resolve, saying.length * 25 + 1000));
+    }
+    finally {
+        cleanup();
+        // Remove the event listeners
+        process.removeListener('exit', cleanup);
+        process.removeListener('SIGINT', cleanup);
+    }
+}

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

@@ -16,13 +16,15 @@ export declare function getDirectusUrl(): Promise<string>;
  */
 export declare function getDirectusToken(directusUrl: string): Promise<string>;
 /**
-   * Initialize the Directus API with the provided flags
-   * @param flags - The validated ApplyFlags
-   */
+ * Initialize the Directus API with the provided flags and log in the user
+ * @param flags - The validated ApplyFlags
+ * @returns {Promise<void>} - Returns nothing
+*/
 export declare function initializeDirectusApi(flags: AuthFlags): Promise<void>;
 /**
- * Validate the authentication flags
- * @param flags - The AuthFlags
- */
+* Validate the authentication flags
+* @param flags - The AuthFlags
+* @returns {void} - Errors if the flags are invalid
+*/
 export declare function validateAuthFlags(flags: AuthFlags): void;
 export {};

package/dist/lib/utils/auth.js

@@ -1,42 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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"));
+import { readMe } from '@directus/sdk';
+import { text, log, isCancel } from '@clack/prompts';
+import { ux } from '@oclif/core';
+import { api } from '../sdk.js';
+import catchError from './catch-error.js';
+import validateUrl from './validate-url.js';
 /**
  * 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' });
+export async function getDirectusUrl() {
+    const directusUrl = await text({
+        placeholder: 'http://localhost:8055',
+        message: 'What is your Directus URL?',
+    });
+    if (isCancel(directusUrl)) {
+        log.info('Exiting...');
+        ux.exit(0);
+    }
     // Validate URL
-    if (!(0, validate_url_1.default)(directusUrl)) {
-        core_1.ux.warn('Invalid URL');
+    if (!validateUrl(directusUrl)) {
+        ux.warn('Invalid URL');
         return getDirectusUrl();
     }
-    sdk_2.api.initialize(directusUrl);
+    api.initialize(directusUrl);
     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?');
+export async function getDirectusToken(directusUrl) {
+    const directusToken = await text({
+        placeholder: 'admin-token-here',
+        message: 'What is your Directus Admin Token?',
+    });
+    if (isCancel(directusToken)) {
+        log.info('Exiting...');
+        ux.exit(0);
+    }
     // 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)());
+        await api.loginWithToken(directusToken);
+        const response = await api.client.request(readMe());
         return directusToken;
     }
     catch (error) {
-        (0, catch_error_1.default)(error, {
+        catchError(error, {
             context: {
                 directusUrl,
                 message: 'Invalid token. Please try again.',
@@ -46,40 +56,39 @@ async function getDirectusToken(directusUrl) {
         return 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);
+ * Initialize the Directus API with the provided flags and log in the user
+ * @param flags - The validated ApplyFlags
+ * @returns {Promise<void>} - Returns nothing
+*/
+export async function initializeDirectusApi(flags) {
+    api.initialize(flags.directusUrl);
     try {
         if (flags.directusToken) {
-            await sdk_2.api.loginWithToken(flags.directusToken);
+            await api.loginWithToken(flags.directusToken);
         }
         else if (flags.userEmail && flags.userPassword) {
-            await sdk_2.api.login(flags.userEmail, flags.userPassword);
+            await 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}`);
+        const response = await api.client.request(readMe());
+        ux.stdout(`-- 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.', {
+        catchError('-- 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) {
+* Validate the authentication flags
+* @param flags - The AuthFlags
+* @returns {void} - Errors if the flags are invalid
+*/
+export function validateAuthFlags(flags) {
     if (!flags.directusUrl) {
-        core_1.ux.error('Directus URL is required.');
+        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.');
+        ux.error('Either Directus token or email and password are required.');
     }
 }
-exports.validateAuthFlags = validateAuthFlags;

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

@@ -1,18 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const sdk_1 = require("../sdk");
-const logger_1 = require("../utils/logger");
+import { ux } from '@oclif/core';
+import { DirectusError } from '../sdk.js';
+import { logger } from '../utils/logger.js';
 /**
  * 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 = {}) {
+export default function catchError(error, options = {}) {
     const { context = {}, fatal = false, logToFile = true } = options;
     let errorMessage;
-    if (error instanceof sdk_1.DirectusError) {
+    if (error instanceof DirectusError) {
         errorMessage = error.message;
     }
     else if (error instanceof Error) {
@@ -29,13 +27,12 @@ function catchError(error, options = {}) {
     // 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);
+        ux.error(formattedMessage);
     }
     else {
-        core_1.ux.warn(formattedMessage);
+        ux.warn(formattedMessage);
     }
     if (logToFile) {
-        logger_1.logger.log('error', errorMessage, context);
+        logger.log('error', errorMessage, context);
     }
 }
-exports.default = catchError;

package/dist/lib/utils/check-template.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
-async function checkTemplate(dir) {
+import readFile from '../utils/read-file.js';
+export default async function checkTemplate(dir) {
     // Check for the collections,fields, and relations files
     try {
-        const collections = (0, read_file_1.default)('collections', dir);
-        const fields = (0, read_file_1.default)('fields', dir);
+        const collections = readFile('collections', dir);
+        const fields = readFile('fields', dir);
         const isCollectionsOk = collections.length > 0 && fields.length > 0;
         return isCollectionsOk;
     }
@@ -14,4 +11,3 @@ async function checkTemplate(dir) {
         console.error(error);
     }
 }
-exports.default = checkTemplate;

package/dist/lib/utils/chunk-array.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.chunkArray = void 0;
-function chunkArray(array, size) {
+export function chunkArray(array, size) {
     return Array.from({ length: Math.ceil(array.length / size) }, (_, index) => array.slice(index * size, (index + 1) * size));
 }
-exports.chunkArray = chunkArray;

package/dist/lib/utils/ensure-dir.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureDir(dir: string): void;
+export declare function ensureDirSync(dir: string): void;

package/dist/lib/utils/ensure-dir.js

@@ -0,0 +1,11 @@
+import { existsSync, mkdirSync } from 'node:fs';
+export function ensureDir(dir) {
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+export function ensureDirSync(dir) {
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}

package/dist/lib/utils/filter-fields.js

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 // Utility function to remove relationship data (arrays of integers or UUIDs) from system collection data. Used for when custom fields are added to system collections. The relational data should be populated when the actual data is loaded.
-function filterFields(dataArray, systemFields) {
+export default function filterFields(dataArray, systemFields) {
     return dataArray.map(item => {
         for (const key of Object.keys(item)) {
             if (!systemFields.includes(key)) {
@@ -19,4 +17,3 @@ function filterFields(dataArray, systemFields) {
         return item;
     });
 }
-exports.default = filterFields;

package/dist/lib/utils/get-role-ids.d.ts

@@ -1,5 +1,5 @@
 export default function getRoleIds(dir: string): Promise<{
-    email: string;
+    email: any;
     legacyAdminRoleId: string;
     newAdminRoleId: string;
 }>;

package/dist/lib/utils/get-role-ids.js

@@ -1,16 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const sdk_1 = require("@directus/sdk");
-const sdk_2 = require("../sdk");
-const read_file_1 = tslib_1.__importDefault(require("./read-file"));
-async function getRoleIds(dir) {
-    var _a;
-    const roles = (0, read_file_1.default)('roles', dir);
+import { readMe } from '@directus/sdk';
+import { api } from '../sdk.js';
+import readFile from './read-file.js';
+export default async function getRoleIds(dir) {
+    const roles = readFile('roles', dir);
     // Legacy admin role may be undefined if the admin role was renamed in the source Directus project.
-    const legacyAdminRoleId = (_a = roles.find(role => role.name === 'Administrator')) === null || _a === void 0 ? void 0 : _a.id;
-    const currentUser = await sdk_2.api.client.request((0, sdk_1.readMe)());
+    const legacyAdminRoleId = roles.find(role => role.name === 'Administrator')?.id;
+    const currentUser = await api.client.request(readMe());
     const newAdminRoleId = currentUser.role;
     return { email: currentUser.email, legacyAdminRoleId, newAdminRoleId };
 }
-exports.default = getRoleIds;

package/dist/lib/utils/get-template.js

@@ -1,48 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGithubTemplate = exports.getInteractiveLocalTemplate = exports.getLocalTemplate = exports.getCommunityTemplates = void 0;
-const tslib_1 = require("tslib");
-const giget_1 = require("giget");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const path_1 = tslib_1.__importDefault(require("./path"));
-const read_templates_1 = require("./read-templates");
-const transform_github_url_1 = require("./transform-github-url");
-async function getCommunityTemplates() {
-    const downloadDir = (0, path_1.default)(node_path_1.default.join(__dirname, '..', 'downloads', 'official'), false);
+import { downloadTemplate } from 'giget';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path, { dirname } from 'pathe';
+import { COMMUNITY_TEMPLATE_REPO } from '../constants.js';
+import resolvePathAndCheckExistence from './path.js';
+import { readAllTemplates, readTemplate } from './read-templates.js';
+import { transformGitHubUrl } from './transform-github-url.js';
+// Create __dirname equivalent for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function getCommunityTemplates() {
+    const downloadDir = resolvePathAndCheckExistence(path.join(__dirname, '..', 'downloads', 'official'), false);
     if (!downloadDir) {
-        throw new Error(`Invalid download directory: ${node_path_1.default.join(__dirname, '..', 'downloads', 'official')}`);
+        throw new Error(`Invalid download directory: ${path.join(__dirname, '..', 'downloads', 'official')}`);
     }
     try {
-        const { dir } = await (0, giget_1.downloadTemplate)('github:directus-labs/directus-templates', {
+        const { dir } = await downloadTemplate(COMMUNITY_TEMPLATE_REPO.string, {
             dir: downloadDir,
             force: true,
         });
-        return await (0, read_templates_1.readAllTemplates)(dir);
+        return await readAllTemplates(dir);
     }
     catch (error) {
         throw new Error(`Failed to download community templates: ${error}`);
     }
 }
-exports.getCommunityTemplates = getCommunityTemplates;
-async function getLocalTemplate(localTemplateDir) {
-    const resolvedDir = (0, path_1.default)(localTemplateDir);
+export async function getLocalTemplate(localTemplateDir) {
+    const resolvedDir = resolvePathAndCheckExistence(localTemplateDir);
     if (!resolvedDir) {
         throw new Error('Directory does not exist.');
     }
-    return (0, read_templates_1.readTemplate)(resolvedDir);
+    return readTemplate(resolvedDir);
 }
-exports.getLocalTemplate = getLocalTemplate;
-async function getInteractiveLocalTemplate(localTemplateDir) {
-    const resolvedDir = (0, path_1.default)(localTemplateDir);
+export async function getInteractiveLocalTemplate(localTemplateDir) {
+    const resolvedDir = resolvePathAndCheckExistence(localTemplateDir);
     if (!resolvedDir) {
         throw new Error('Directory does not exist.');
     }
-    const directTemplate = await (0, read_templates_1.readTemplate)(resolvedDir);
+    const directTemplate = await readTemplate(resolvedDir);
     if (directTemplate) {
         return [directTemplate];
     }
-    const templates = await (0, read_templates_1.readAllTemplates)(resolvedDir);
+    const templates = await readAllTemplates(resolvedDir);
     if (templates.length === 0) {
         // If no templates found, search nested directories
         const nestedTemplates = await findNestedTemplates(resolvedDir, 2);
@@ -53,16 +52,15 @@ async function getInteractiveLocalTemplate(localTemplateDir) {
     }
     return templates;
 }
-exports.getInteractiveLocalTemplate = getInteractiveLocalTemplate;
 async function findNestedTemplates(dir, depth) {
     if (depth === 0)
         return [];
     const templates = [];
-    const entries = await node_fs_1.default.promises.readdir(dir, { withFileTypes: true });
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
         if (entry.isDirectory()) {
-            const fullPath = node_path_1.default.join(dir, entry.name);
-            const dirTemplates = await (0, read_templates_1.readAllTemplates)(fullPath);
+            const fullPath = path.join(dir, entry.name);
+            const dirTemplates = await readAllTemplates(fullPath);
             templates.push(...dirTemplates);
             if (dirTemplates.length === 0 && depth > 1) {
                 // If no templates found and we can go deeper, search subdirectories
@@ -73,26 +71,25 @@ async function findNestedTemplates(dir, depth) {
     }
     return templates;
 }
-async function getGithubTemplate(ghTemplateUrl) {
+export async function getGithubTemplate(ghTemplateUrl) {
     try {
-        const ghString = await (0, transform_github_url_1.transformGitHubUrl)(ghTemplateUrl);
-        const downloadDir = (0, path_1.default)(node_path_1.default.join(__dirname, '..', 'downloads', 'github'), false);
+        const ghString = await transformGitHubUrl(ghTemplateUrl);
+        const downloadDir = resolvePathAndCheckExistence(path.join(__dirname, '..', 'downloads', 'github'), false);
         if (!downloadDir) {
-            throw new Error(`Invalid download directory: ${node_path_1.default.join(__dirname, '..', 'downloads', 'github')}`);
+            throw new Error(`Invalid download directory: ${path.join(__dirname, '..', 'downloads', 'github')}`);
         }
-        const { dir } = await (0, giget_1.downloadTemplate)(ghString, {
+        const { dir } = await downloadTemplate(ghString, {
             dir: downloadDir,
             force: true,
             forceClean: true,
         });
-        const resolvedDir = (0, path_1.default)(dir);
+        const resolvedDir = resolvePathAndCheckExistence(dir);
         if (!resolvedDir) {
             throw new Error(`Downloaded template directory does not exist: ${dir}`);
         }
-        return (0, read_templates_1.readTemplate)(resolvedDir);
+        return readTemplate(resolvedDir);
     }
     catch (error) {
         throw new Error(`Failed to download GitHub template: ${error}`);
     }
 }
-exports.getGithubTemplate = getGithubTemplate;

package/dist/lib/utils/logger.js

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
-const tslib_1 = require("tslib");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
+import fs from 'node:fs';
+import path from 'pathe';
 class Logger {
+    static instance;
+    logFilePath;
     constructor() {
         this.initializeLogFile();
     }
@@ -21,13 +19,13 @@ class Logger {
         this.writeToFile(logEntry);
     }
     initializeLogFile() {
-        // @ts-ignore
+        // @ts-ignore - ignore
         const timestamp = new Date().toISOString().replaceAll(/[.:]/g, '-');
-        const logDir = node_path_1.default.join(process.cwd(), '.directus-template-cli', 'logs');
-        if (!node_fs_1.default.existsSync(logDir)) {
-            node_fs_1.default.mkdirSync(logDir, { recursive: true });
+        const logDir = path.join(process.cwd(), '.directus-template-cli', 'logs');
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
         }
-        this.logFilePath = node_path_1.default.join(logDir, `run-${timestamp}.log`);
+        this.logFilePath = path.join(logDir, `run-${timestamp}.log`);
         // Write initial timestamp to the log file
         this.writeToFile(`Log started at ${timestamp}\n`);
     }
@@ -45,11 +43,11 @@ class Logger {
     }
     writeToFile(message) {
         try {
-            node_fs_1.default.appendFileSync(this.logFilePath, message);
+            fs.appendFileSync(this.logFilePath, message);
         }
         catch (error) {
             console.error('Error writing to log file:', error);
         }
     }
 }
-exports.logger = Logger.getInstance();
+export const logger = Logger.getInstance();

package/dist/lib/utils/open-url.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
-function openUrl(url) {
+import { exec } from 'node:child_process';
+export default function openUrl(url) {
     switch (process.platform) {
         case 'darwin': {
-            (0, node_child_process_1.exec)(`open ${url}`);
+            exec(`open ${url}`);
             break;
         }
         case 'win32': {
-            (0, node_child_process_1.exec)(`start ${url}`);
+            exec(`start ${url}`);
             break;
         }
         default: {
-            (0, node_child_process_1.exec)(`xdg-open ${url}`);
+            exec(`xdg-open ${url}`);
         }
     }
 }
-exports.default = openUrl;

package/dist/lib/utils/parse-github-url.d.ts

@@ -0,0 +1,19 @@
+interface GitHubUrlParts {
+    owner: string;
+    path?: string;
+    ref?: string;
+    repo: string;
+}
+/**
+ * Parse a GitHub URL or path into its components
+ * @param url The URL or path to parse
+ * @returns The parsed components
+ */
+export declare function parseGitHubUrl(url: string): GitHubUrlParts;
+/**
+ * Creates a giget-compatible string from GitHub URL parts
+ * @param parts The parsed GitHub URL parts
+ * @returns A string in the format 'gh:owner/repo#ref[/path]'
+ */
+export declare function createGigetString(parts: GitHubUrlParts): string;
+export {};