directus-template-cli 0.5.0-beta.2 → 0.5.0-beta.20

package/dist/lib/load/load-translations.js

@@ -3,38 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const sdk_1 = require("@directus/sdk");
 const core_1 = require("@oclif/core");
+const constants_1 = require("../constants");
 const sdk_2 = require("../sdk");
 const catch_error_1 = tslib_1.__importDefault(require("../utils/catch-error"));
 const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadTranslations(dir) {
-    core_1.ux.action.start('Loading translations');
     const translations = (0, read_file_1.default)('translations', dir);
-    // Fetch existing translations
-    const existingTranslations = await sdk_2.api.client.request((0, sdk_1.readTranslations)({
-        limit: -1,
-    }));
-    const existingTranslationKeys = new Set(existingTranslations.map(t => `${t.language}_${t.key}`));
-    const newTranslations = translations.filter(t => {
-        const key = `${t.language}_${t.key}`;
-        if (existingTranslationKeys.has(key)) {
-            core_1.ux.log(`Skipping existing translation: ${key}`);
-            return false;
+    core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${translations.length} translations`));
+    if (translations && translations.length > 0) {
+        // Fetch existing translations
+        const existingTranslations = await sdk_2.api.client.request((0, sdk_1.readTranslations)({
+            limit: -1,
+        }));
+        const existingTranslationKeys = new Set(existingTranslations.map(t => `${t.language}_${t.key}`));
+        const newTranslations = translations.filter(t => {
+            const key = `${t.language}_${t.key}`;
+            if (existingTranslationKeys.has(key)) {
+                return false;
+            }
+            return true;
+        });
+        if (newTranslations.length > 0) {
+            try {
+                await sdk_2.api.client.request((0, sdk_1.createTranslations)(newTranslations));
+            }
+            catch (error) {
+                (0, catch_error_1.default)(error);
+            }
         }
-        return true;
-    });
-    if (newTranslations.length > 0) {
-        try {
-            await sdk_2.api.client.request((0, sdk_1.createTranslations)(newTranslations));
-            core_1.ux.log(`Created ${newTranslations.length} new translations`);
+        else {
+            // ux.info('-- No new translations to create')
         }
-        catch (error) {
-            (0, catch_error_1.default)(error);
-        }
-    }
-    else {
-        core_1.ux.log('No new translations to create');
     }
     core_1.ux.action.stop();
-    core_1.ux.log('Loaded translations');
 }
 exports.default = loadTranslations;

package/dist/lib/load/load-users.js

@@ -3,48 +3,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const sdk_1 = require("@directus/sdk");
 const core_1 = require("@oclif/core");
+const constants_1 = require("../constants");
 const sdk_2 = require("../sdk");
 const catch_error_1 = tslib_1.__importDefault(require("../utils/catch-error"));
 const get_role_ids_1 = tslib_1.__importDefault(require("../utils/get-role-ids"));
 const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadUsers(dir) {
     const users = (0, read_file_1.default)('users', dir);
-    core_1.ux.action.start(`Loading ${users.length} users`);
-    const { legacyAdminRoleId, newAdminRoleId } = await (0, get_role_ids_1.default)(dir);
-    const incomingUserEmails = users.map(user => user.email);
-    const existingUsers = await sdk_2.api.client.request((0, sdk_1.readUsers)({
-        filter: {
-            email: {
-                _in: incomingUserEmails,
-            },
-        },
-        limit: -1,
-    }));
-    const filteredUsers = users.map(user => {
-        // If the user is an admin, we need to change their role to the new admin role
-        const isAdmin = user.role === legacyAdminRoleId;
-        user.role = isAdmin ? newAdminRoleId : user.role;
-        // Delete the unneeded fields
-        delete user.last_page;
-        delete user.token;
-        delete user.policies;
-        // Delete passwords to prevent setting to *******
-        delete user.password;
-        return user;
-    });
-    for await (const user of filteredUsers) {
-        // If user email is null or already in use, we just delete the email key to pass validation and retain the user and any realationship data
-        if (user.email === null || existingUsers.some(existingUser => existingUser.email === user.email)) {
-            delete user.email;
-        }
-        try {
-            await sdk_2.api.client.request((0, sdk_1.createUser)(user));
-        }
-        catch (error) {
-            (0, catch_error_1.default)(error);
+    core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${users.length} users`));
+    if (users && users.length > 0) {
+        const { legacyAdminRoleId, newAdminRoleId } = await (0, get_role_ids_1.default)(dir);
+        const existingUsers = await sdk_2.api.client.request((0, sdk_1.readUsers)({
+            limit: -1,
+        }));
+        const filteredUsers = users.map(user => {
+            // If the user is an admin, we need to change their role to the new admin role
+            const isAdmin = user.role === legacyAdminRoleId;
+            user.role = isAdmin ? newAdminRoleId : user.role;
+            // Delete the unneeded fields
+            delete user.last_page;
+            delete user.token;
+            delete user.policies;
+            // Delete passwords to prevent setting to *******
+            delete user.password;
+            return user;
+        });
+        for await (const user of filteredUsers) {
+            const existingUserWithSameId = existingUsers && Array.isArray(existingUsers)
+                ? existingUsers.find(existing => existing.id === user.id)
+                : undefined;
+            const existingUserWithSameEmail = existingUsers && Array.isArray(existingUsers)
+                ? existingUsers.find(existing => existing.email === user.email)
+                : undefined;
+            if (existingUserWithSameId) {
+                // Skip if there's an existing user with the same id
+                continue;
+            }
+            if (existingUserWithSameEmail) {
+                // Delete email if there's an existing user with the same email but different id
+                delete user.email;
+            }
+            if (user.email === null) {
+                // Delete email if it's null
+                delete user.email;
+            }
+            try {
+                await sdk_2.api.client.request((0, sdk_1.createUser)(user));
+            }
+            catch (error) {
+                (0, catch_error_1.default)(error);
+            }
         }
     }
     core_1.ux.action.stop();
-    core_1.ux.log('Loaded users');
 }
 exports.default = loadUsers;

package/dist/lib/load/update-required-fields.d.ts

@@ -0,0 +1 @@
+export default function updateRequiredFields(dir: string): Promise<void>;

package/dist/lib/load/update-required-fields.js

@@ -0,0 +1,24 @@
+"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 constants_1 = require("../constants");
+const sdk_2 = require("../sdk");
+const catch_error_1 = tslib_1.__importDefault(require("../utils/catch-error"));
+const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
+async function updateRequiredFields(dir) {
+    const fieldsToUpdate = (0, read_file_1.default)('fields', dir)
+        .filter(field => { var _a, _b; return field.meta.required === true || ((_a = field.schema) === null || _a === void 0 ? void 0 : _a.is_nullable) === false || ((_b = field.schema) === null || _b === void 0 ? void 0 : _b.is_unique) === true; });
+    core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Updating ${fieldsToUpdate.length} fields to required`));
+    for await (const field of fieldsToUpdate) {
+        try {
+            await sdk_2.api.client.request((0, sdk_1.updateField)(field.collection, field.field, { meta: { ...field.meta }, schema: { ...field.schema } }));
+        }
+        catch (error) {
+            (0, catch_error_1.default)(error);
+        }
+    }
+    core_1.ux.action.stop();
+}
+exports.default = updateRequiredFields;

package/dist/lib/sdk.d.ts

@@ -1,13 +1,31 @@
 import type { AuthenticationClient, RestClient } from '@directus/sdk';
 export interface Schema {
-    any: any;
+}
+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;
     private limiter;
     constructor();
+    getToken(): null | string;
     initialize(url: string): void;
-    setAuthToken(token: string): void;
+    login(email: string, password: string): Promise<void>;
+    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,32 +1,147 @@
 "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 core_1 = require("@oclif/core");
 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, // Max 10 concurrent requests
-            minTime: 100, // 100ms between requests
-            retryCount: 3, // Retry failed requests up to 3 times
-            retryDelay: 3000, // Wait 3 seconds between retries
+            maxConcurrent: 10,
+            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;
+                    core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Rate limited. Retrying after ${delay}ms`);
+                    return delay;
+                }
+                if (statusCode === 503) {
+                    const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : 5000;
+                    core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Server under pressure. Retrying after ${delay}ms`);
+                    return delay;
+                }
+                // If the status code is 400 or 401, we don't want to retry
+                if (statusCode === 400 || statusCode === 401) {
+                    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);
+                core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Request failed. Retrying after ${delay}ms`);
+                return delay;
+            }
+            core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Max retries reached, not retrying further`);
+        });
+        this.limiter.on('retry', (error, jobInfo) => {
+            core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Retrying job (attempt ${jobInfo.retryCount + 1})`);
+        });
+        this.limiter.on('depleted', empty => {
+            if (empty) {
+                core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Rate limit quota depleted. Requests will be queued.`);
+            }
         });
     }
+    getToken() {
+        var _a, _b;
+        return (_b = (_a = this.authData) === null || _a === void 0 ? void 0 : _a.access_token) !== null && _b !== void 0 ? _b : null;
+    }
     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)())
-            .with((0, sdk_1.authentication)());
+            .with((0, sdk_1.authentication)('json', {
+            autoRefresh: true,
+            storage: {
+                get: () => this.authData,
+                set: data => {
+                    this.authData = data;
+                },
+            },
+        }));
     }
-    setAuthToken(token) {
+    async login(email, password) {
         if (!this.client) {
             throw new Error('API client is not initialized. Call initialize() first.');
         }
-        this.client.setToken(token);
+        await this.client.login(email, password);
+    }
+    async loginWithToken(token) {
+        if (!this.client) {
+            throw new Error('API client is not initialized. Call initialize() first.');
+        }
+        await this.client.setToken(token);
+    }
+    async logout() {
+        if (!this.client) {
+            throw new Error('API client is not initialized. Call initialize() first.');
+        }
+        await this.client.logout();
+        this.authData = null;
+    }
+    async refreshToken() {
+        if (!this.client) {
+            throw new Error('API client is not initialized. Call initialize() first.');
+        }
+        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();

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,13 +22,17 @@ 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 {
-        sdk_2.api.setAuthToken(directusToken);
+        await sdk_2.api.loginWithToken(directusToken);
         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}`);
         return directusToken;
     }
     catch (error) {
@@ -39,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)
-            : `Unknown 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 = [
-        contextString && `Context: ${contextString}`,
         errorMessage,
+        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/dist/lib/utils/get-template.d.ts

@@ -4,5 +4,6 @@ interface Template {
 }
 export declare function getCommunityTemplates(): Promise<Template[]>;
 export declare function getLocalTemplate(localTemplateDir: string): Promise<Template>;
+export declare function getInteractiveLocalTemplate(localTemplateDir: string): Promise<Template[]>;
 export declare function getGithubTemplate(ghTemplateUrl: string): Promise<Template>;
 export {};

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGithubTemplate = exports.getLocalTemplate = exports.getCommunityTemplates = void 0;
+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");
@@ -33,6 +34,46 @@ async function getLocalTemplate(localTemplateDir) {
     return (0, read_templates_1.readTemplate)(resolvedDir);
 }
 exports.getLocalTemplate = getLocalTemplate;
+async function getInteractiveLocalTemplate(localTemplateDir) {
+    const resolvedDir = (0, path_1.default)(localTemplateDir);
+    if (!resolvedDir) {
+        throw new Error('Directory does not exist.');
+    }
+    const directTemplate = await (0, read_templates_1.readTemplate)(resolvedDir);
+    if (directTemplate) {
+        return [directTemplate];
+    }
+    const templates = await (0, read_templates_1.readAllTemplates)(resolvedDir);
+    if (templates.length === 0) {
+        // If no templates found, search nested directories
+        const nestedTemplates = await findNestedTemplates(resolvedDir, 2);
+        if (nestedTemplates.length === 0) {
+            throw new Error('No valid templates found in the specified directory or its subdirectories.');
+        }
+        return nestedTemplates;
+    }
+    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 });
+    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);
+            templates.push(...dirTemplates);
+            if (dirTemplates.length === 0 && depth > 1) {
+                // If no templates found and we can go deeper, search subdirectories
+                const nestedTemplates = await findNestedTemplates(fullPath, depth - 1);
+                templates.push(...nestedTemplates);
+            }
+        }
+    }
+    return templates;
+}
 async function getGithubTemplate(ghTemplateUrl) {
     try {
         const ghString = await (0, transform_github_url_1.transformGitHubUrl)(ghTemplateUrl);

package/dist/lib/utils/read-file.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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"));
+const catch_error_1 = tslib_1.__importDefault(require("./catch-error"));
 function readFile(file, dir) {
     const filePath = node_path_1.default.join(dir, `${file}.json`); // Use path.join for proper path resolution
     if (!node_fs_1.default.existsSync(filePath)) {
-        throw new Error(`File not found: ${filePath}`); // Improved error handling
+        (0, catch_error_1.default)(`File not found: ${filePath}`);
     }
     const fileContents = node_fs_1.default.readFileSync(filePath, 'utf8');
     const obj = JSON.parse(fileContents);