directus-template-cli 0.7.0-beta.5 → 0.7.0-beta.6

package/dist/lib/init/index.js

@@ -7,57 +7,88 @@ import { glob } from 'glob';
 import fs from 'node:fs';
 import { detectPackageManager, installDependencies } from 'nypm';
 import path from 'pathe';
+import dotenv from 'dotenv';
 import ApplyCommand from '../../commands/apply.js';
 import { createDocker } from '../../services/docker.js';
 import catchError from '../utils/catch-error.js';
 import { createGigetString, parseGitHubUrl } from '../utils/parse-github-url.js';
-import { DIRECTUS_CONFIG, DOCKER_CONFIG } from './config.js';
-export async function init(dir, flags) {
+import { readTemplateConfig } from '../utils/template-config.js';
+import { DOCKER_CONFIG } from './config.js';
+export async function init({ dir, flags }) {
     // Check target directory
     const shouldForce = flags.overrideDir;
     if (fs.existsSync(dir) && !shouldForce) {
         throw new Error('Directory already exists. Use --override-dir to override.');
     }
-    const frontendDir = path.join(dir, flags.frontend);
+    // If template is a URL, we need to handle it differently
+    const isDirectUrl = flags.template?.startsWith('http');
     const directusDir = path.join(dir, 'directus');
     let template;
+    let packageManager = null;
     try {
         // Download the template from GitHub
         const parsedUrl = parseGitHubUrl(flags.template);
+        // If it's a direct URL, we download the entire repository
+        // Otherwise, we use the template from the starters repo
         template = await downloadTemplate(createGigetString(parsedUrl), {
             dir,
             force: shouldForce,
         });
-        // Cleanup the template
-        if (flags.frontend) {
-            // Ensure directus directory exists before cleaning up
+        // For direct URLs, we need to check if there's a directus directory
+        // If not, assume the entire repo is a directus template
+        if (isDirectUrl) {
             if (!fs.existsSync(directusDir)) {
+                // Move all files to directus directory
                 fs.mkdirSync(directusDir, { recursive: true });
+                const files = fs.readdirSync(dir);
+                for (const file of files) {
+                    if (file !== 'directus') {
+                        fs.renameSync(path.join(dir, file), path.join(directusDir, file));
+                    }
+                }
             }
-            // Read and parse package.json
-            const packageJsonPath = path.join(dir, 'package.json');
-            if (!fs.existsSync(packageJsonPath)) {
-                throw new Error('package.json not found in template');
+        }
+        // Read template configuration
+        const templateInfo = readTemplateConfig(dir);
+        let frontendDir;
+        // Handle frontends based on template configuration
+        if (flags.frontend && templateInfo) {
+            // Find the selected frontend in the configuration
+            const selectedFrontend = templateInfo.frontendOptions.find(f => f.id === flags.frontend);
+            if (!selectedFrontend) {
+                throw new Error(`Frontend "${flags.frontend}" not found in template configuration`);
             }
-            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-            const templateConfig = packageJson['directus:template'];
-            // Get all frontend paths from the configuration
-            const frontendPaths = Object.values(templateConfig?.frontends || {})
-                .map(frontend => frontend.path.replace(/^\.\//, ''))
-                .filter(path => path !== flags.frontend); // Exclude the selected frontend
-            // Remove unused frontend directories
-            for (const frontendPath of frontendPaths) {
-                const pathToRemove = path.join(dir, frontendPath);
-                if (fs.existsSync(pathToRemove)) {
-                    fs.rmSync(pathToRemove, { recursive: true });
+            // Remove all frontend directories except the selected one
+            for (const frontend of templateInfo.frontendOptions) {
+                if (frontend.id !== flags.frontend) {
+                    const pathToRemove = path.join(dir, frontend.path);
+                    if (fs.existsSync(pathToRemove)) {
+                        fs.rmSync(pathToRemove, { recursive: true });
+                    }
                 }
             }
+            // Move the selected frontend to the correct location if needed
+            frontendDir = path.join(dir, selectedFrontend.path);
+            if (frontendDir !== path.join(dir, flags.frontend)) {
+                fs.renameSync(frontendDir, path.join(dir, flags.frontend));
+                frontendDir = path.join(dir, flags.frontend);
+            }
         }
+        const directusInfo = {
+            email: '',
+            password: '',
+            url: '',
+        };
         // Find and copy all .env.example files
         const envFiles = glob.sync(path.join(dir, '**', '.env.example'));
         for (const file of envFiles) {
             const envFile = file.replace('.env.example', '.env');
             fs.copyFileSync(file, envFile);
+            // Read default Directus login info from .env
+            const parsedEnv = dotenv.parse(fs.readFileSync(file, 'utf8'));
+            directusInfo.email = parsedEnv.ADMIN_EMAIL;
+            directusInfo.password = parsedEnv.ADMIN_PASSWORD;
+            directusInfo.url = parsedEnv.PUBLIC_URL;
         }
         // Start Directus and apply template only if directus directory exists
         if (fs.existsSync(directusDir)) {
@@ -70,12 +101,10 @@ export async function init(dir, flags) {
             }
             try {
                 await dockerService.startContainers(directusDir);
-                const healthCheckUrl = `${DIRECTUS_CONFIG.url}:${DIRECTUS_CONFIG.port}${DOCKER_CONFIG.healthCheckEndpoint}`;
+                const healthCheckUrl = `${directusInfo.url}${DOCKER_CONFIG.healthCheckEndpoint}`;
                 await dockerService.waitForHealthy(healthCheckUrl);
                 const templatePath = path.join(directusDir, 'template');
-                // const s = spinner()
-                // s.start(`Attempting to apply template from: ${templatePath}`)
-                // ux.stdout(`Attempting to apply template from: ${templatePath}`)
+                ux.stdout(`Attempting to apply template from: ${templatePath}`);
                 await ApplyCommand.run([
                     '--directusUrl=http://localhost:8055',
                     '-p',
@@ -83,50 +112,48 @@ export async function init(dir, flags) {
                     '--userPassword=d1r3ctu5',
                     `--templateLocation=${templatePath}`,
                 ]);
-                // s.stop('Template applied!')
             }
             catch (error) {
                 ux.error('Failed to start Directus containers or apply template');
                 throw error;
             }
         }
-        // Install dependencies for frontend if it exists
-        if (flags.installDeps && fs.existsSync(frontendDir)) {
+        // Install dependencies if requested
+        if (flags.installDeps) {
             const s = spinner();
             s.start('Installing dependencies');
-            // ux.action.start('Installing dependencies')
             try {
-                const packageManager = await detectPackageManager(frontendDir);
-                await installDependencies({
-                    cwd: frontendDir,
-                    packageManager,
-                    silent: true,
-                });
+                if (fs.existsSync(frontendDir)) {
+                    packageManager = await detectPackageManager(frontendDir);
+                    await installDependencies({
+                        cwd: frontendDir,
+                        packageManager,
+                        silent: true,
+                    });
+                }
             }
             catch (error) {
                 ux.warn('Failed to install dependencies');
                 throw error;
             }
-            // ux.action.stop()
             s.stop('Dependencies installed!');
         }
         // Initialize Git repo
         if (flags.gitInit) {
             const s = spinner();
             s.start('Initializing git repository');
-            // ux.action.start('Initializing git repository')
             await initGit(dir);
-            // ux.action.stop()
             s.stop('Git repository initialized!');
         }
         // Finishing up
         const relativeDir = path.relative(process.cwd(), dir);
-        const nextSteps = `- Directus is running on http://localhost:8055 \n- Navigate to your project directory using ${chalk.cyan(`cd ${relativeDir}`)} and start developing! \n- Review the \`./README.md\` file for next steps.`;
+        const directusText = `- Directus is running on ${directusInfo.url ?? 'http://localhost:8055'}. You can login with the email: ${chalk.cyan(directusInfo.email)} and password: ${chalk.cyan(directusInfo.password)}. \n`;
+        const frontendText = flags.frontend ? `- To start the frontend, run ${chalk.cyan(`cd ${flags.frontend}`)} and then ${chalk.cyan(`${packageManager?.name} run dev`)}. \n` : '';
+        const projectText = `- Navigate to your project directory using ${chalk.cyan(`cd ${relativeDir}`)}. \n`;
+        const readmeText = '- Review the \`./README.md\` file for more information and next steps.';
+        const nextSteps = chalk.white(`${directusText}${projectText}${frontendText}${readmeText}`);
         note(nextSteps, 'Next Steps');
-        // ux.stdout('You\'ll find the following directories in your project:')
-        // ux.stdout('• directus')
-        // ux.stdout(`• ${flags.frontend}`)
-        outro(`Problems? Join the community on Discord at ${chalk.underline(chalk.cyan('https://directus.chat'))}`);
+        outro(`Problems or questions? Hop into the community on Discord at ${chalk.underline(chalk.cyan('https://directus.chat'))}`);
     }
     catch (error) {
         catchError(error, {
@@ -137,7 +164,7 @@ export async function init(dir, flags) {
     }
     return {
         directusDir,
-        frontendDir,
+        frontendDir: flags.frontend ? path.join(dir, flags.frontend) : undefined,
         template,
     };
 }
@@ -148,9 +175,7 @@ export async function init(dir, flags) {
  */
 async function initGit(targetDir) {
     try {
-        // ux.action.start('Initializing git repository')
         await execa('git', ['init'], { cwd: targetDir });
-        // ux.action.stop()
     }
     catch (error) {
         catchError(error, {

package/dist/lib/load/index.d.ts

@@ -1,13 +1,2 @@
-interface ApplyFlags {
-    content: boolean;
-    dashboards: boolean;
-    extensions: boolean;
-    files: boolean;
-    flows: boolean;
-    permissions: boolean;
-    schema: boolean;
-    settings: boolean;
-    users: boolean;
-}
+import type { ApplyFlags } from './apply-flags.js';
 export default function apply(dir: string, flags: ApplyFlags): Promise<{}>;
-export {};

package/dist/lib/types.d.ts

@@ -0,0 +1,18 @@
+export interface DirectusTemplateFrontend {
+    name: string;
+    path: string;
+}
+export interface DirectusTemplateConfig {
+    name: string;
+    description: string;
+    template: string;
+    frontends: {
+        [key: string]: DirectusTemplateFrontend;
+    };
+}
+export interface TemplatePackageJson {
+    name: string;
+    version: string;
+    description: string;
+    'directus:template'?: DirectusTemplateConfig;
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -8,21 +8,23 @@ interface AuthFlags {
  * Get the Directus URL from the user
  * @returns The Directus URL
  */
-export declare function getDirectusUrl(): Promise<string | symbol>;
+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 | symbol>;
+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,5 +1,5 @@
 import { readMe } from '@directus/sdk';
-import { text } from '@clack/prompts';
+import { text, log, isCancel } from '@clack/prompts';
 import { ux } from '@oclif/core';
 import { api } from '../sdk.js';
 import catchError from './catch-error.js';
@@ -13,6 +13,10 @@ export async function getDirectusUrl() {
         placeholder: 'http://localhost:8055',
         message: 'What is your Directus URL?',
     });
+    if (isCancel(directusUrl)) {
+        log.info('Exiting...');
+        ux.exit(0);
+    }
     // Validate URL
     if (!validateUrl(directusUrl)) {
         ux.warn('Invalid URL');
@@ -31,6 +35,10 @@ export async function getDirectusToken(directusUrl) {
         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 api.loginWithToken(directusToken);
@@ -49,9 +57,10 @@ export async function getDirectusToken(directusUrl) {
     }
 }
 /**
-   * 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 async function initializeDirectusApi(flags) {
     api.initialize(flags.directusUrl);
     try {
@@ -71,9 +80,10 @@ export async function initializeDirectusApi(flags) {
     }
 }
 /**
- * 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 function validateAuthFlags(flags) {
     if (!flags.directusUrl) {
         ux.error('Directus URL is required.');

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

@@ -5,10 +5,15 @@ interface GitHubUrlParts {
     repo: string;
 }
 /**
-   * Parse a GitHub URL into its components.
-   * @param url - The GitHub URL to parse.
-   * @returns The parsed GitHub URL components.
-   */
+ * 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;
-export declare function createGigetString({ owner, path, ref, repo }: GitHubUrlParts): string;
+/**
+ * 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 {};

package/dist/lib/utils/parse-github-url.js

@@ -1,49 +1,89 @@
-import { DEFAULT_REPO } from '../constants.js';
+import { DEFAULT_BRANCH, DEFAULT_REPO } from '../constants.js';
 /**
-   * Parse a GitHub URL into its components.
-   * @param url - The GitHub URL to parse.
-   * @returns The parsed GitHub URL components.
-   */
-export function parseGitHubUrl(url) {
-    // Handle simple template names by using default repo
-    if (!url.includes('/')) {
-        return { ...DEFAULT_REPO, path: url };
-    }
-    // Handle different GitHub URL formats:
-    // - https://github.com/owner/repo
-    // - https://github.com/owner/repo/tree/branch
-    // - https://github.com/owner/repo/tree/branch/path
-    // - owner/repo
-    // - owner/repo/path
+ * Clean and normalize a GitHub URL
+ * Handles various formats:
+ * - Full URLs with .git
+ * - URLs with query parameters
+ * - URLs with hash fragments
+ * - URLs with branches/refs
+ * - Repository paths
+ * @param url The URL or path to clean
+ * @returns Cleaned URL without .git, queries, or hashes
+ */
+function cleanGitHubUrl(url) {
     try {
-        if (url.startsWith('https://github.com/')) {
-            url = url.replace('https://github.com/', '');
+        // If it's not a URL, return as is (might be a path)
+        if (!url.includes('://')) {
+            return url.replace(/\.git$/, '');
         }
-        const parts = url.split('/');
-        const owner = parts[0];
-        const repo = parts[1];
-        let path = '';
-        let ref;
-        if (parts.length > 2) {
-            if (parts[2] === 'tree' && parts.length > 3) {
-                ref = parts[3];
-                path = parts.slice(4).join('/');
-            }
-            else {
-                path = parts.slice(2).join('/');
+        // Parse the URL
+        const parsed = new URL(url);
+        // Remove .git suffix from pathname
+        parsed.pathname = parsed.pathname.replace(/\.git$/, '');
+        // Remove search params and hash
+        parsed.search = '';
+        parsed.hash = '';
+        return parsed.toString();
+    }
+    catch (error) {
+        // If URL parsing fails, just remove .git suffix
+        return url.replace(/\.git$/, '');
+    }
+}
+/**
+ * Parse a GitHub URL or path into its components
+ * @param url The URL or path to parse
+ * @returns The parsed components
+ */
+export function parseGitHubUrl(url) {
+    if (!url) {
+        throw new Error('URL is required');
+    }
+    // Clean the URL first
+    const cleanedUrl = cleanGitHubUrl(url);
+    // Handle full GitHub URLs
+    if (cleanedUrl.includes('github.com')) {
+        try {
+            const parsed = new URL(cleanedUrl);
+            const parts = parsed.pathname.split('/').filter(Boolean);
+            if (parts.length < 2) {
+                throw new Error('Invalid GitHub URL format');
             }
+            const [owner, repo, ...rest] = parts;
+            const path = rest.length > 0 ? rest.join('/') : undefined;
+            const ref = parsed.searchParams.get('ref') || DEFAULT_BRANCH;
+            return { owner, repo, path, ref };
+        }
+        catch (error) {
+            throw new Error(`Invalid GitHub URL: ${url}`);
         }
-        return { owner, path, ref, repo };
     }
-    catch {
-        throw new Error(`Invalid GitHub URL format: ${url}`);
+    // Handle repository paths (owner/repo format)
+    const parts = cleanedUrl.split('/').filter(Boolean);
+    if (parts.length >= 2) {
+        const [owner, repo, ...rest] = parts;
+        const path = rest.length > 0 ? rest.join('/') : undefined;
+        return { owner, repo, path, ref: DEFAULT_BRANCH };
     }
+    // Handle simple template names using DEFAULT_REPO
+    return {
+        ...DEFAULT_REPO,
+        path: cleanedUrl // The template name becomes the subpath
+    };
 }
-export function createGigetString({ owner, path, ref, repo }) {
-    let source = `github:${owner}/${repo}`;
-    if (path)
-        source += `/${path}`;
-    if (ref)
-        source += `#${ref}`;
-    return source;
+/**
+ * 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 function createGigetString(parts) {
+    // For the default repo case with a template name
+    if (parts.owner === DEFAULT_REPO.owner && parts.repo === DEFAULT_REPO.repo) {
+        return `gh:${parts.owner}/${parts.repo}/${parts.path}#${DEFAULT_REPO.ref}`;
+    }
+    // For other GitHub URLs
+    const base = `gh:${parts.owner}/${parts.repo}`;
+    const path = parts.path ? `/${parts.path}` : '';
+    const ref = parts.ref ? `#${parts.ref}` : '';
+    return `${base}${path}${ref}`;
 }

package/dist/lib/utils/sanitize-flags.d.ts

@@ -0,0 +1,3 @@
+export declare const sanitizeFlags: (flags: Record<string, unknown>) => {
+    [k: string]: unknown;
+};

package/dist/lib/utils/sanitize-flags.js

@@ -0,0 +1,4 @@
+const SENSITIVE_FLAGS = ['userEmail', 'userPassword', 'directusToken'];
+export const sanitizeFlags = (flags) => {
+    return Object.fromEntries(Object.entries(flags).filter(([key]) => !SENSITIVE_FLAGS.includes(key)));
+};

package/dist/lib/utils/template-config.d.ts

@@ -0,0 +1,16 @@
+import type { DirectusTemplateConfig } from '../types.js';
+export interface TemplateInfo {
+    config: DirectusTemplateConfig;
+    frontendOptions: Array<{
+        id: string;
+        name: string;
+        path: string;
+    }>;
+}
+/**
+ * Read and validate the template configuration from a directory
+ * @param dir Directory containing the template
+ * @returns Template configuration and frontend options
+ * @throws Error if package.json is missing or invalid
+ */
+export declare function readTemplateConfig(dir: string): TemplateInfo | null;

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

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import path from 'pathe';
+/**
+ * Read and validate the template configuration from a directory
+ * @param dir Directory containing the template
+ * @returns Template configuration and frontend options
+ * @throws Error if package.json is missing or invalid
+ */
+export function readTemplateConfig(dir) {
+    try {
+        const packageJsonPath = path.join(dir, 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            return null;
+        }
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const templateConfig = packageJson['directus:template'];
+        if (!templateConfig) {
+            return null;
+        }
+        // Convert frontends object to array of options
+        const frontendOptions = Object.entries(templateConfig.frontends || {}).map(([id, frontend]) => ({
+            id,
+            name: frontend.name,
+            path: frontend.path.replace(/^\.\//, ''), // Remove leading ./
+        }));
+        return {
+            config: templateConfig,
+            frontendOptions,
+        };
+    }
+    catch (error) {
+        return null;
+    }
+}

package/dist/services/docker.js

@@ -1,7 +1,62 @@
 import { spinner } from '@clack/prompts';
 import { execa } from 'execa';
+import net from 'node:net';
+import { ux } from '@oclif/core';
 import catchError from '../lib/utils/catch-error.js';
 import { waitFor } from '../lib/utils/wait.js';
+/**
+ * Check if a port is in use and what's using it
+ * @param port The port to check
+ * @returns Object indicating if port is in use and what's using it
+ */
+async function checkPort(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', async (err) => {
+            if (err.code === 'EADDRINUSE') {
+                // Try to get information about what's using the port
+                try {
+                    const { stdout } = await execa('lsof', ['-i', `:${port}`]);
+                    const process = stdout.split('\n')[1]?.split(/\s+/)[0]; // Get process name
+                    resolve({ inUse: true, process });
+                }
+                catch {
+                    resolve({ inUse: true });
+                }
+            }
+            else {
+                resolve({ inUse: false });
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve({ inUse: false });
+        });
+        server.listen(port);
+    });
+}
+/**
+ * Check if required ports are available and warn if they're in use
+ * @returns Promise<void>
+ */
+async function checkRequiredPorts() {
+    const portsToCheck = [
+        { port: 8055, name: 'Directus API' },
+        { port: 5432, name: 'PostgreSQL' },
+    ];
+    let hasConflicts = false;
+    for (const { port, name } of portsToCheck) {
+        const status = await checkPort(port);
+        if (status.inUse) {
+            hasConflicts = true;
+            const process = status.process ? ` by ${status.process}` : '';
+            ux.warn(`Port ${port} (${name}) is already in use${process}`);
+        }
+    }
+    if (hasConflicts) {
+        ux.warn('Please stop any conflicting services before continuing.');
+    }
+}
 /**
  * Check if Docker is installed and running
  * @returns {Promise<DockerCheckResult>} Docker installation and running status
@@ -39,12 +94,12 @@ async function checkDocker() {
  */
 async function startContainers(cwd) {
     try {
-        // ux.action.start('Starting Docker containers')
+        // Check if required ports are available
+        await checkRequiredPorts();
         const s = spinner();
         s.start('Starting Docker containers');
         return execa('docker-compose', ['up', '-d'], {
             cwd,
-            // stdio: 'inherit',
         }).then(() => {
             s.stop('Docker containers running!');
         });
@@ -67,7 +122,6 @@ async function stopContainers(cwd) {
     try {
         return execa('docker-compose', ['down'], {
             cwd,
-            // stdio: 'inherit',
         }).then(() => { });
     }
     catch (error) {