directus-template-cli 0.5.0-beta.8 → 0.5.0

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/load/index.js

@@ -19,6 +19,7 @@ const load_roles_1 = tslib_1.__importDefault(require("./load-roles"));
 const load_settings_1 = tslib_1.__importDefault(require("./load-settings"));
 const load_translations_1 = tslib_1.__importDefault(require("./load-translations"));
 const load_users_1 = tslib_1.__importDefault(require("./load-users"));
+const update_required_fields_1 = tslib_1.__importDefault(require("./update-required-fields"));
 async function apply(dir, flags) {
     const source = dir + '/src';
     const isTemplateOk = await (0, check_template_1.default)(source);
@@ -29,14 +30,14 @@ async function apply(dir, flags) {
         await (0, load_collections_1.default)(source);
         await (0, load_relations_1.default)(source);
     }
-    if (flags.permissions) {
+    if (flags.permissions || flags.users) {
         await (0, load_roles_1.default)(source);
         await (0, load_policies_1.default)(source);
-        await (0, load_access_1.default)(source);
         await (0, load_permissions_1.default)(source);
-    }
-    if (flags.users) {
-        await (0, load_users_1.default)(source);
+        if (flags.users) {
+            await (0, load_users_1.default)(source);
+        }
+        await (0, load_access_1.default)(source);
     }
     if (flags.files) {
         await (0, load_folders_1.default)(source);
@@ -45,6 +46,9 @@ async function apply(dir, flags) {
     if (flags.content) {
         await (0, load_data_1.default)(source);
     }
+    if (flags.schema) {
+        await (0, update_required_fields_1.default)(source);
+    }
     if (flags.dashboards) {
         await (0, load_dashboards_1.default)(source);
     }

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

@@ -5,49 +5,57 @@ const core_1 = require("@oclif/core");
 const constants_1 = require("../constants");
 const sdk_1 = 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 loadAccess(dir) {
     const access = (0, read_file_1.default)('access', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${access.length} accesses`));
-    // Fetch existing accesses
-    const existingAccesses = await sdk_1.api.client.request(() => ({
-        method: 'GET',
-        params: {
-            limit: -1,
-        },
-        path: '/access',
-    }));
-    const existingAccessById = new Map(existingAccesses.map(acc => [acc.id, acc]));
-    const existingAccessByCompositeKey = new Map(existingAccesses.map(acc => [getCompositeKey(acc), acc]));
-    for await (const acc of access) {
-        try {
-            if (existingAccessById.has(acc.id)) {
-                continue;
+    if (access && access.length > 0) {
+        // Fetch existing accesses
+        const existingAccesses = await sdk_1.api.client.request(() => ({
+            method: 'GET',
+            params: {
+                limit: -1,
+            },
+            path: '/access',
+        }));
+        const { legacyAdminRoleId, newAdminRoleId } = await (0, get_role_ids_1.default)(dir);
+        const existingAccessById = new Map(existingAccesses.map(acc => [acc.id, acc]));
+        const existingAccessByCompositeKey = new Map(existingAccesses.map(acc => [getCompositeKey(acc), acc]));
+        for await (const acc of access) {
+            try {
+                if (existingAccessById.has(acc.id)) {
+                    continue;
+                }
+                const compositeKey = getCompositeKey(acc);
+                if (existingAccessByCompositeKey.has(compositeKey)) {
+                    continue;
+                }
+                // If the role is null, delete the role key to avoid errors
+                if (acc.role === null) {
+                    delete acc.role;
+                }
+                // If the role is the legacy admin role, update it to the new admin role
+                if (acc.role === legacyAdminRoleId) {
+                    acc.role = newAdminRoleId;
+                }
+                await sdk_1.api.client.request(() => ({
+                    body: JSON.stringify(acc),
+                    method: 'POST',
+                    path: '/access',
+                }));
+                // Add the new access to our maps
+                existingAccessById.set(acc.id, acc);
+                existingAccessByCompositeKey.set(compositeKey, acc);
             }
-            const compositeKey = getCompositeKey(acc);
-            if (existingAccessByCompositeKey.has(compositeKey)) {
-                continue;
+            catch (error) {
+                (0, catch_error_1.default)(error, {
+                    context: {
+                        access: acc,
+                        operation: 'createAccess',
+                    },
+                });
             }
-            // If the role is null, delete the role key to avoid errors
-            if (acc.role === null) {
-                delete acc.role;
-            }
-            await sdk_1.api.client.request(() => ({
-                body: JSON.stringify(acc),
-                method: 'POST',
-                path: '/access',
-            }));
-            // Add the new access to our maps
-            existingAccessById.set(acc.id, acc);
-            existingAccessByCompositeKey.set(compositeKey, acc);
-        }
-        catch (error) {
-            (0, catch_error_1.default)(error, {
-                context: {
-                    access: acc,
-                    operation: 'createAccess',
-                },
-            });
         }
     }
     core_1.ux.action.stop();

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

@@ -33,8 +33,24 @@ async function processCollections(collectionsToAdd, fieldsToAdd) {
         }
     }
 }
+const removeRequiredorIsNullable = (field) => {
+    var _a, _b, _c;
+    if (((_a = field.meta) === null || _a === void 0 ? void 0 : _a.required) === true) {
+        field.meta.required = false;
+    }
+    if (((_b = field.schema) === null || _b === void 0 ? void 0 : _b.is_nullable) === false) {
+        // eslint-disable-next-line camelcase
+        field.schema.is_nullable = true;
+    }
+    if (((_c = field.schema) === null || _c === void 0 ? void 0 : _c.is_unique) === true) {
+        // eslint-disable-next-line camelcase
+        field.schema.is_unique = false;
+    }
+    return field;
+};
 async function addNewCollectionWithFields(collection, allFields) {
-    const collectionFields = allFields.filter(field => field.collection === collection.collection);
+    const collectionFields = allFields.filter(field => field.collection === collection.collection)
+        .map(field => removeRequiredorIsNullable(field));
     const collectionWithoutGroup = {
         ...collection,
         fields: collectionFields,
@@ -44,7 +60,8 @@ async function addNewCollectionWithFields(collection, allFields) {
     await sdk_2.api.client.request((0, sdk_1.createCollection)(collectionWithoutGroup));
 }
 async function addNewFieldsToExistingCollection(collectionName, fieldsToAdd, existingFields) {
-    const collectionFieldsToAdd = fieldsToAdd.filter(field => field.collection === collectionName);
+    const collectionFieldsToAdd = fieldsToAdd.filter(field => field.collection === collectionName)
+        .map(field => removeRequiredorIsNullable(field));
     const existingCollectionFields = existingFields.filter((field) => field.collection === collectionName);
     for await (const field of collectionFieldsToAdd) {
         if (!existingCollectionFields.some((existingField) => existingField.field === field.field)) {
@@ -82,6 +99,7 @@ async function addCustomFieldsOnSystemCollections(fields) {
         try {
             const fieldExists = existingFields.some((existingField) => existingField.collection === field.collection && existingField.field === field.field);
             if (!fieldExists) {
+                // @ts-expect-error string
                 await sdk_2.api.client.request((0, sdk_1.createField)(field.collection, field));
             }
         }

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

@@ -11,31 +11,33 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadDashboards(dir) {
     const dashboards = (0, read_file_1.default)('dashboards', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${dashboards.length} dashboards`));
-    // Fetch existing dashboards
-    const existingDashboards = await sdk_2.api.client.request((0, sdk_1.readDashboards)({
-        limit: -1,
-    }));
-    const existingDashboardIds = new Set(existingDashboards.map(dashboard => dashboard.id));
-    const filteredDashboards = dashboards.filter(dashboard => {
-        if (existingDashboardIds.has(dashboard.id)) {
-            return false;
-        }
-        return true;
-    }).map(dash => {
-        const newDash = { ...dash };
-        delete newDash.panels;
-        return newDash;
-    });
-    await Promise.all(filteredDashboards.map(async (dashboard) => {
-        try {
-            await sdk_2.api.client.request((0, sdk_1.createDashboard)(dashboard));
-        }
-        catch (error) {
-            (0, catch_error_1.default)(error);
-        }
-    }));
-    await loadPanels(dir);
-    core_1.ux.action.stop();
+    if (dashboards && dashboards.length > 0) {
+        // Fetch existing dashboards
+        const existingDashboards = await sdk_2.api.client.request((0, sdk_1.readDashboards)({
+            limit: -1,
+        }));
+        const existingDashboardIds = new Set(existingDashboards.map(dashboard => dashboard.id));
+        const filteredDashboards = dashboards.filter(dashboard => {
+            if (existingDashboardIds.has(dashboard.id)) {
+                return false;
+            }
+            return true;
+        }).map(dash => {
+            const newDash = { ...dash };
+            delete newDash.panels;
+            return newDash;
+        });
+        await Promise.all(filteredDashboards.map(async (dashboard) => {
+            try {
+                await sdk_2.api.client.request((0, sdk_1.createDashboard)(dashboard));
+            }
+            catch (error) {
+                (0, catch_error_1.default)(error);
+            }
+        }));
+        await loadPanels(dir);
+        core_1.ux.action.stop();
+    }
 }
 exports.default = loadDashboards;
 async function loadPanels(dir) {

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

@@ -37,12 +37,12 @@ async function loadSkeletonRecords(dir) {
         // Filter out existing records
         const newData = data.filter(entry => !existingPrimaryKeys.has(entry[primaryKeyField]));
         if (newData.length === 0) {
-            core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Skipping ${name}: No new records to add`);
+            // ux.log(`${ux.colorize('dim', '--')} Skipping ${name}: No new records to add`)
             return;
         }
         const batches = (0, chunk_array_1.chunkArray)(newData, BATCH_SIZE).map(batch => batch.map(entry => ({ [primaryKeyField]: entry[primaryKeyField] })));
         await Promise.all(batches.map(batch => uploadBatch(name, batch, sdk_1.createItems)));
-        core_1.ux.log(`${core_1.ux.colorize('dim', '--')} Added ${newData.length} new skeleton records to ${name}`);
+        // ux.log(`${ux.colorize('dim', '--')} Added ${newData.length} new skeleton records to ${name}`)
     }));
     core_1.ux.action.status = 'Loaded skeleton records';
 }
@@ -108,8 +108,8 @@ async function loadSingletons(dir) {
         const sourceDir = node_path_1.default.resolve(dir, 'content');
         const data = (0, read_file_1.default)(name, sourceDir);
         try {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const { user_created, user_updated, ...cleanedData } = data;
+            // @ts-expect-error
             await sdk_2.api.client.request((0, sdk_1.updateSingleton)(name, cleanedData));
         }
         catch (error) {

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

@@ -13,52 +13,48 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadFiles(dir) {
     const files = (0, read_file_1.default)('files', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${files.length} files`));
-    try {
-        const fileIds = files.map(file => file.id);
-        // Fetch only the files we're interested in
-        const existingFiles = await sdk_2.api.client.request((0, sdk_1.readFiles)({
-            fields: ['id', 'filename_disk'],
-            filter: {
-                id: {
-                    _in: fileIds,
-                },
-            },
-            limit: -1,
-        }));
-        const existingFileIds = new Set(existingFiles.map(file => file.id));
-        const existingFileNames = new Set(existingFiles.map(file => file.filename_disk));
-        const filesToUpload = files.filter(file => {
-            if (existingFileIds.has(file.id)) {
-                return false;
-            }
-            if (existingFileNames.has(file.filename_disk)) {
-                return false;
-            }
-            return true;
-        });
-        await Promise.all(filesToUpload.map(async (asset) => {
-            const fileName = asset.filename_disk;
-            const assetPath = node_path_1.default.resolve(dir, 'assets', fileName);
-            const fileStream = new Blob([(0, node_fs_1.readFileSync)(assetPath)], { type: asset.type });
-            const form = new formdata_node_1.FormData();
-            form.append('id', asset.id);
-            if (asset.title)
-                form.append('title', asset.title);
-            if (asset.description)
-                form.append('description', asset.description);
-            if (asset.folder)
-                form.append('folder', asset.folder);
-            form.append('file', fileStream, fileName);
-            try {
-                await sdk_2.api.client.request((0, sdk_1.uploadFiles)(form));
-            }
-            catch (error) {
-                (0, catch_error_1.default)(error);
-            }
-        }));
-    }
-    catch (error) {
-        (0, catch_error_1.default)(error);
+    if (files && files.length > 0) {
+        try {
+            // Fetch only the files we're interested in
+            const existingFiles = await sdk_2.api.client.request((0, sdk_1.readFiles)({
+                fields: ['id', 'filename_disk'],
+                limit: -1,
+            }));
+            const existingFileIds = new Set(existingFiles.map(file => file.id));
+            const existingFileNames = new Set(existingFiles.map(file => file.filename_disk));
+            const filesToUpload = files.filter(file => {
+                if (existingFileIds.has(file.id)) {
+                    return false;
+                }
+                if (existingFileNames.has(file.filename_disk)) {
+                    return false;
+                }
+                return true;
+            });
+            await Promise.all(filesToUpload.map(async (asset) => {
+                const fileName = asset.filename_disk;
+                const assetPath = node_path_1.default.resolve(dir, 'assets', fileName);
+                const fileStream = new Blob([(0, node_fs_1.readFileSync)(assetPath)], { type: asset.type });
+                const form = new formdata_node_1.FormData();
+                form.append('id', asset.id);
+                if (asset.title)
+                    form.append('title', asset.title);
+                if (asset.description)
+                    form.append('description', asset.description);
+                if (asset.folder)
+                    form.append('folder', asset.folder);
+                form.append('file', fileStream, fileName);
+                try {
+                    await sdk_2.api.client.request((0, sdk_1.uploadFiles)(form));
+                }
+                catch (error) {
+                    (0, catch_error_1.default)(error);
+                }
+            }));
+        }
+        catch (error) {
+            (0, catch_error_1.default)(error);
+        }
     }
     core_1.ux.action.stop();
 }

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

@@ -10,47 +10,48 @@ const catch_error_1 = tslib_1.__importDefault(require("../utils/catch-error"));
 const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadFlows(dir) {
     const flows = (0, read_file_1.default)('flows', dir);
+    const allOperations = (0, read_file_1.default)('operations', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${flows.length} flows`));
-    try {
-        // Fetch existing flows
-        const existingFlows = await sdk_2.api.client.request((0, sdk_1.readFlows)({
-            limit: -1,
-        }));
-        const existingFlowIds = new Set(existingFlows.map(flow => flow.id));
-        const cleanedUpFlows = flows.map(flow => {
-            const { operations, ...cleanFlow } = flow;
-            return { cleanFlow, operations };
-        });
-        const newFlows = cleanedUpFlows.filter(({ cleanFlow }) => !existingFlowIds.has(cleanFlow.id));
-        const results = await Promise.allSettled(newFlows.map(({ cleanFlow }) => sdk_2.api.client.request((0, sdk_1.createFlow)(cleanFlow))));
-        const createdFlowIds = new Set();
-        for (const [index, result] of results.entries()) {
-            if (result.status === 'fulfilled') {
-                createdFlowIds.add(newFlows[index].cleanFlow.id);
-            }
-            else {
-                (0, catch_error_1.default)(result.reason);
+    if (flows && flows.length > 0) {
+        try {
+            // Fetch existing flows
+            const existingFlows = await sdk_2.api.client.request((0, sdk_1.readFlows)({
+                limit: -1,
+            }));
+            const existingFlowIds = new Set(existingFlows.map(flow => flow.id));
+            const newFlows = flows.filter(flow => !existingFlowIds.has(flow.id));
+            const results = await Promise.allSettled(newFlows.map(flow => sdk_2.api.client.request((0, sdk_1.createFlow)(flow))));
+            const createdFlowIds = new Set();
+            for (const [index, result] of results.entries()) {
+                if (result.status === 'fulfilled') {
+                    createdFlowIds.add(newFlows[index].id);
+                }
+                else {
+                    (0, catch_error_1.default)(result.reason);
+                }
             }
+            // Filter operations for newly created flows
+            const newOperations = allOperations.filter(operation => createdFlowIds.has(operation.flow));
+            await loadOperations(newOperations);
+        }
+        catch (error) {
+            (0, catch_error_1.default)(error);
+        }
+        finally {
+            core_1.ux.action.stop();
         }
-        // Only load operations for newly created flows
-        const newOperations = newFlows
-            .filter(({ cleanFlow }) => createdFlowIds.has(cleanFlow.id))
-            .flatMap(({ operations }) => operations);
-        await loadOperations(newOperations);
-    }
-    catch (error) {
-        (0, catch_error_1.default)(error);
-    }
-    finally {
-        core_1.ux.action.stop();
     }
 }
 exports.default = loadFlows;
 async function loadOperations(operations) {
     core_1.ux.action.status = `Loading ${operations.length} operations`;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const opsIds = operations.map(({ reject, resolve, ...rest }) => rest);
+        const opsIds = operations.map(operation => {
+            const opCopy = { ...operation };
+            delete opCopy.reject;
+            delete opCopy.resolve;
+            return opCopy;
+        });
         await sdk_2.api.client.request((0, sdk_1.createOperations)(opsIds));
         const results = await Promise.allSettled(operations.map(operation => sdk_2.api.client.request((0, sdk_1.updateOperation)(operation.id, {
             reject: operation.reject,

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

@@ -10,40 +10,42 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadFolders(dir) {
     const folders = (0, read_file_1.default)('folders', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${folders.length} folders`));
-    try {
-        // Fetch existing folders
-        const existingFolders = await sdk_2.api.client.request((0, sdk_1.readFolders)({
-            limit: -1,
-        }));
-        const existingFolderIds = new Set(existingFolders.map(folder => folder.id));
-        const foldersToAdd = folders.filter(folder => {
-            if (existingFolderIds.has(folder.id)) {
-                return false;
-            }
-            return true;
-        });
-        if (foldersToAdd.length > 0) {
-            const folderSkeleton = foldersToAdd.map(folder => ({ id: folder.id, name: folder.name }));
-            // Create the folders
-            await sdk_2.api.client.request((0, sdk_1.createFolders)(folderSkeleton));
-            // Update the folders with relationships concurrently
-            await Promise.all(foldersToAdd.map(async (folder) => {
-                const { id, ...rest } = folder;
-                try {
-                    await sdk_2.api.client.request((0, sdk_1.updateFolder)(id, rest));
-                }
-                catch (error) {
-                    (0, catch_error_1.default)(error);
-                }
+    if (folders && folders.length > 0) {
+        try {
+            // Fetch existing folders
+            const existingFolders = await sdk_2.api.client.request((0, sdk_1.readFolders)({
+                limit: -1,
             }));
+            const existingFolderIds = new Set(existingFolders.map(folder => folder.id));
+            const foldersToAdd = folders.filter(folder => {
+                if (existingFolderIds.has(folder.id)) {
+                    return false;
+                }
+                return true;
+            });
+            if (foldersToAdd.length > 0) {
+                const folderSkeleton = foldersToAdd.map(folder => ({ id: folder.id, name: folder.name }));
+                // Create the folders
+                await sdk_2.api.client.request((0, sdk_1.createFolders)(folderSkeleton));
+                // Update the folders with relationships concurrently
+                await Promise.all(foldersToAdd.map(async (folder) => {
+                    const { id, ...rest } = folder;
+                    try {
+                        await sdk_2.api.client.request((0, sdk_1.updateFolder)(id, rest));
+                    }
+                    catch (error) {
+                        (0, catch_error_1.default)(error);
+                    }
+                }));
+            }
+            else {
+                // ux.info('-- No new folders to create')
+            }
         }
-        else {
-            // ux.info('-- No new folders to create')
+        catch (error) {
+            (0, catch_error_1.default)(error);
         }
     }
-    catch (error) {
-        (0, catch_error_1.default)(error);
-    }
     core_1.ux.action.stop();
 }
 exports.default = loadFolders;

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

@@ -10,19 +10,21 @@ const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 async function loadPermissions(dir) {
     const permissions = (0, read_file_1.default)('permissions', dir);
     core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${permissions.length} permissions`));
-    try {
-        const existingPermissions = await sdk_2.api.client.request((0, sdk_1.readPermissions)({
-            limit: -1,
-        }));
-        const existingPermissionKeys = new Set(existingPermissions.map(p => `${p.collection}:${p.action}:${p.policy}`));
-        // Filter out duplicates
-        const newPermissions = permissions.filter(newPerm => !existingPermissionKeys.has(`${newPerm.collection}:${newPerm.action}:${newPerm.policy}`));
-        if (newPermissions.length > 0) {
-            await sdk_2.api.client.request((0, sdk_1.createPermissions)(newPermissions));
+    if (permissions && permissions.length > 0) {
+        try {
+            const existingPermissions = await sdk_2.api.client.request((0, sdk_1.readPermissions)({
+                limit: -1,
+            }));
+            const existingPermissionKeys = new Set(existingPermissions.map(p => `${p.collection}:${p.action}:${p.policy}`));
+            // Filter out duplicates
+            const newPermissions = permissions.filter(newPerm => !existingPermissionKeys.has(`${newPerm.collection}:${newPerm.action}:${newPerm.policy}`));
+            if (newPermissions.length > 0) {
+                await sdk_2.api.client.request((0, sdk_1.createPermissions)(newPermissions));
+            }
+        }
+        catch (error) {
+            (0, catch_error_1.default)(error);
         }
-    }
-    catch (error) {
-        (0, catch_error_1.default)(error);
     }
     core_1.ux.action.stop();
 }