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

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

@@ -1,19 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadPanels = void 0;
-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 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`));
+import { createDashboard, createPanel, readDashboards, readPanels } from '@directus/sdk';
+import { ux } from '@oclif/core';
+import { DIRECTUS_PINK } from '../constants.js';
+import { api } from '../sdk.js';
+import catchError from '../utils/catch-error.js';
+import readFile from '../utils/read-file.js';
+export default async function loadDashboards(dir) {
+    const dashboards = readFile('dashboards', dir);
+    ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading ${dashboards.length} dashboards`));
     if (dashboards && dashboards.length > 0) {
         // Fetch existing dashboards
-        const existingDashboards = await sdk_2.api.client.request((0, sdk_1.readDashboards)({
+        const existingDashboards = await api.client.request(readDashboards({
             limit: -1,
         }));
         const existingDashboardIds = new Set(existingDashboards.map(dashboard => dashboard.id));
@@ -29,22 +25,21 @@ async function loadDashboards(dir) {
         });
         await Promise.all(filteredDashboards.map(async (dashboard) => {
             try {
-                await sdk_2.api.client.request((0, sdk_1.createDashboard)(dashboard));
+                await api.client.request(createDashboard(dashboard));
             }
             catch (error) {
-                (0, catch_error_1.default)(error);
+                catchError(error);
             }
         }));
         await loadPanels(dir);
-        core_1.ux.action.stop();
+        ux.action.stop();
     }
 }
-exports.default = loadDashboards;
-async function loadPanels(dir) {
-    const panels = (0, read_file_1.default)('panels', dir);
-    core_1.ux.action.status = `Loading ${panels.length} panels`;
+export async function loadPanels(dir) {
+    const panels = readFile('panels', dir);
+    ux.action.status = `Loading ${panels.length} panels`;
     // Fetch existing panels
-    const existingPanels = await sdk_2.api.client.request((0, sdk_1.readPanels)({
+    const existingPanels = await api.client.request(readPanels({
         limit: -1,
     }));
     const existingPanelIds = new Set(existingPanels.map(panel => panel.id));
@@ -56,11 +51,10 @@ async function loadPanels(dir) {
     });
     await Promise.all(filteredPanels.map(async (panel) => {
         try {
-            await sdk_2.api.client.request((0, sdk_1.createPanel)(panel));
+            await api.client.request(createPanel(panel));
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
         }
     }));
 }
-exports.loadPanels = loadPanels;

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

@@ -1,27 +1,23 @@
-"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 node_path_1 = tslib_1.__importDefault(require("node:path"));
-const constants_1 = require("../constants");
-const sdk_2 = require("../sdk");
-const catch_error_1 = tslib_1.__importDefault(require("../utils/catch-error"));
-const chunk_array_1 = require("../utils/chunk-array");
-const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
+import { createItems, readItems, updateItemsBatch, updateSingleton } from '@directus/sdk';
+import { ux } from '@oclif/core';
+import path from 'pathe';
+import { DIRECTUS_PINK } from '../constants.js';
+import { api } from '../sdk.js';
+import catchError from '../utils/catch-error.js';
+import { chunkArray } from '../utils/chunk-array.js';
+import readFile from '../utils/read-file.js';
 const BATCH_SIZE = 50;
-async function loadData(dir) {
-    const collections = (0, read_file_1.default)('collections', dir);
-    core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading data for ${collections.length} collections`));
+export default async function loadData(dir) {
+    const collections = readFile('collections', dir);
+    ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading data for ${collections.length} collections`));
     await loadSkeletonRecords(dir);
     await loadFullData(dir);
     await loadSingletons(dir);
-    core_1.ux.action.stop();
+    ux.action.stop();
 }
-exports.default = loadData;
 async function loadSkeletonRecords(dir) {
-    core_1.ux.action.status = 'Loading skeleton records';
-    const collections = (0, read_file_1.default)('collections', dir);
+    ux.action.status = 'Loading skeleton records';
+    const collections = readFile('collections', dir);
     const primaryKeyMap = await getCollectionPrimaryKeys(dir);
     const userCollections = collections
         .filter(item => !item.collection.startsWith('directus_', 0))
@@ -30,21 +26,21 @@ async function loadSkeletonRecords(dir) {
     await Promise.all(userCollections.map(async (collection) => {
         const name = collection.collection;
         const primaryKeyField = getPrimaryKey(primaryKeyMap, name);
-        const sourceDir = node_path_1.default.resolve(dir, 'content');
-        const data = (0, read_file_1.default)(name, sourceDir);
+        const sourceDir = path.resolve(dir, 'content');
+        const data = readFile(name, sourceDir);
         // Fetch existing primary keys
         const existingPrimaryKeys = await getExistingPrimaryKeys(name, primaryKeyField);
         // Filter out existing records
         const newData = data.filter(entry => !existingPrimaryKeys.has(entry[primaryKeyField]));
         if (newData.length === 0) {
-            // ux.log(`${ux.colorize('dim', '--')} Skipping ${name}: No new records to add`)
+            // ux.stdout(`${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)));
-        // ux.log(`${ux.colorize('dim', '--')} Added ${newData.length} new skeleton records to ${name}`)
+        const batches = chunkArray(newData, BATCH_SIZE).map(batch => batch.map(entry => ({ [primaryKeyField]: entry[primaryKeyField] })));
+        await Promise.all(batches.map(batch => uploadBatch(name, batch, createItems)));
+        // ux.stdout(`${ux.colorize('dim', '--')} Added ${newData.length} new skeleton records to ${name}`)
     }));
-    core_1.ux.action.status = 'Loaded skeleton records';
+    ux.action.status = 'Loaded skeleton records';
 }
 async function getExistingPrimaryKeys(collection, primaryKeyField) {
     const existingKeys = new Set();
@@ -52,8 +48,8 @@ async function getExistingPrimaryKeys(collection, primaryKeyField) {
     const limit = 1000; // Adjust based on your needs and API limits
     while (true) {
         try {
-            // @ts-expect-error string
-            const response = await sdk_2.api.client.request((0, sdk_1.readItems)(collection, {
+            // @ts-ignore
+            const response = await api.client.request(readItems(collection, {
                 fields: [primaryKeyField],
                 limit,
                 page,
@@ -67,7 +63,7 @@ async function getExistingPrimaryKeys(collection, primaryKeyField) {
             page++;
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
             break;
         }
     }
@@ -75,55 +71,53 @@ async function getExistingPrimaryKeys(collection, primaryKeyField) {
 }
 async function uploadBatch(collection, batch, method) {
     try {
-        await sdk_2.api.client.request(method(collection, batch));
+        await api.client.request(method(collection, batch));
     }
     catch (error) {
-        (0, catch_error_1.default)(error);
+        catchError(error);
     }
 }
 async function loadFullData(dir) {
-    core_1.ux.action.status = 'Updating records with full data';
-    const collections = (0, read_file_1.default)('collections', dir);
+    ux.action.status = 'Updating records with full data';
+    const collections = readFile('collections', dir);
     const userCollections = collections
         .filter(item => !item.collection.startsWith('directus_', 0))
         .filter(item => item.schema !== null)
         .filter(item => !item.meta.singleton);
     await Promise.all(userCollections.map(async (collection) => {
         const name = collection.collection;
-        const sourceDir = node_path_1.default.resolve(dir, 'content');
-        const data = (0, read_file_1.default)(name, sourceDir);
-        const batches = (0, chunk_array_1.chunkArray)(data, BATCH_SIZE).map(batch => batch.map(({ user_created, user_updated, ...cleanedRow }) => cleanedRow));
-        await Promise.all(batches.map(batch => uploadBatch(name, batch, sdk_1.updateItemsBatch)));
+        const sourceDir = path.resolve(dir, 'content');
+        const data = readFile(name, sourceDir);
+        const batches = chunkArray(data, BATCH_SIZE).map(batch => batch.map(({ user_created, user_updated, ...cleanedRow }) => cleanedRow));
+        await Promise.all(batches.map(batch => uploadBatch(name, batch, updateItemsBatch)));
     }));
-    core_1.ux.action.status = 'Updated records with full data';
+    ux.action.status = 'Updated records with full data';
 }
 async function loadSingletons(dir) {
-    core_1.ux.action.status = 'Loading data for singleton collections';
-    const collections = (0, read_file_1.default)('collections', dir);
+    ux.action.status = 'Loading data for singleton collections';
+    const collections = readFile('collections', dir);
     const singletonCollections = collections
         .filter(item => !item.collection.startsWith('directus_', 0))
         .filter(item => item.meta.singleton);
     await Promise.all(singletonCollections.map(async (collection) => {
         const name = collection.collection;
-        const sourceDir = node_path_1.default.resolve(dir, 'content');
-        const data = (0, read_file_1.default)(name, sourceDir);
+        const sourceDir = path.resolve(dir, 'content');
+        const data = readFile(name, sourceDir);
         try {
             const { user_created, user_updated, ...cleanedData } = data;
-            // @ts-expect-error
-            await sdk_2.api.client.request((0, sdk_1.updateSingleton)(name, cleanedData));
+            await api.client.request(updateSingleton(name, cleanedData));
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
         }
     }));
-    core_1.ux.action.status = 'Loaded data for singleton collections';
+    ux.action.status = 'Loaded data for singleton collections';
 }
 async function getCollectionPrimaryKeys(dir) {
-    var _a;
-    const fields = (0, read_file_1.default)('fields', dir);
+    const fields = readFile('fields', dir);
     const primaryKeys = {};
     for (const field of fields) {
-        if (field.schema && ((_a = field.schema) === null || _a === void 0 ? void 0 : _a.is_primary_key)) {
+        if (field.schema && field.schema?.is_primary_key) {
             primaryKeys[field.collection] = field.field;
         }
     }
@@ -131,7 +125,7 @@ async function getCollectionPrimaryKeys(dir) {
 }
 function getPrimaryKey(collectionsMap, collection) {
     if (!collectionsMap[collection]) {
-        (0, catch_error_1.default)(`Collection ${collection} not found in collections map`);
+        catchError(`Collection ${collection} not found in collections map`);
     }
     return collectionsMap[collection];
 }

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

@@ -1,14 +1,11 @@
-"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"));
+import { customEndpoint, readExtensions } from '@directus/sdk';
+import { ux } from '@oclif/core';
+import { DIRECTUS_PINK } from '../constants.js';
+import { api } from '../sdk.js';
+import catchError from '../utils/catch-error.js';
+import readFile from '../utils/read-file.js';
 async function installExtension(extension) {
-    await sdk_2.api.client.request((0, sdk_1.customEndpoint)({
+    await api.client.request(customEndpoint({
         body: JSON.stringify({
             extension: extension.id,
             version: extension.version,
@@ -17,60 +14,55 @@ async function installExtension(extension) {
         path: '/extensions/registry/install',
     }));
 }
-async function loadExtensions(dir) {
-    core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, 'Loading extensions'));
+export default async function loadExtensions(dir) {
+    ux.action.start(ux.colorize(DIRECTUS_PINK, 'Loading extensions'));
     try {
-        const extensions = (0, read_file_1.default)('extensions', dir);
+        const extensions = readFile('extensions', dir);
         if (extensions && extensions.length > 0) {
-            const installedExtensions = await sdk_2.api.client.request((0, sdk_1.readExtensions)());
-            const registryExtensions = extensions.filter(ext => { var _a; return ((_a = ext.meta) === null || _a === void 0 ? void 0 : _a.source) === 'registry' && !ext.bundle; });
+            const installedExtensions = await api.client.request(readExtensions());
+            const registryExtensions = extensions.filter(ext => ext.meta?.source === 'registry' && !ext.bundle);
             const bundles = [...new Set(extensions.filter(ext => ext.bundle).map(ext => ext.bundle))];
-            const localExtensions = extensions.filter(ext => { var _a; return ((_a = ext.meta) === null || _a === void 0 ? void 0 : _a.source) === 'local'; });
-            const extensionsToInstall = extensions.filter(ext => {
-                var _a;
-                return ((_a = ext.meta) === null || _a === void 0 ? void 0 : _a.source) === 'registry'
-                    && !ext.bundle
-                    // @ts-expect-error
-                    && !installedExtensions.some(installed => installed.id === ext.id);
-            });
-            core_1.ux.log(`Found ${extensions.length} extensions total: ${registryExtensions.length} registry extensions (including ${bundles.length} bundles), and ${localExtensions.length} local extensions`);
+            const localExtensions = extensions.filter(ext => ext.meta?.source === 'local');
+            const extensionsToInstall = extensions.filter(ext => ext.meta?.source === 'registry'
+                && !ext.bundle
+                // @ts-ignore - ignore
+                && !installedExtensions.some(installed => installed.id === ext.id));
+            ux.stdout(`Found ${extensions.length} extensions total: ${registryExtensions.length} registry extensions (including ${bundles.length} bundles), and ${localExtensions.length} local extensions`);
             if (extensionsToInstall.length > 0) {
-                core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Installing ${extensionsToInstall.length} extensions`));
+                ux.action.start(ux.colorize(DIRECTUS_PINK, `Installing ${extensionsToInstall.length} extensions`));
                 const results = await Promise.allSettled(extensionsToInstall.map(async (ext) => {
-                    var _a, _b, _c;
                     try {
                         await installExtension({
                             id: ext.id,
                             // The extension version UUID is the folder name
-                            version: (_a = ext.meta) === null || _a === void 0 ? void 0 : _a.folder,
+                            version: ext.meta?.folder,
                         });
-                        return `-- Installed ${(_b = ext.schema) === null || _b === void 0 ? void 0 : _b.name}`;
+                        return `-- Installed ${ext.schema?.name}`;
                     }
                     catch (error) {
-                        (0, catch_error_1.default)(error);
-                        return `-- Failed to install ${(_c = ext.schema) === null || _c === void 0 ? void 0 : _c.name}`;
+                        catchError(error);
+                        return `-- Failed to install ${ext.schema?.name}`;
                     }
                 }));
                 for (const result of results) {
                     if (result.status === 'fulfilled') {
-                        core_1.ux.log(result.value);
+                        ux.stdout(result.value);
                     }
                 }
-                core_1.ux.action.stop();
-                core_1.ux.log('Finished installing extensions');
+                ux.action.stop();
+                ux.stdout('Finished installing extensions');
             }
             else {
                 // All extensions are already installed
-                core_1.ux.log('All extensions are already installed');
+                ux.stdout('All extensions are already installed');
             }
             if (localExtensions.length > 0) {
-                core_1.ux.log(`Note: ${localExtensions.length} local extensions need to be installed manually.`);
+                ux.stdout(`Note: ${localExtensions.length} local extensions need to be installed manually.`);
             }
         }
     }
     catch {
-        core_1.ux.log(`${core_1.ux.colorize('dim', '--')} No extensions found or extensions file is empty. Skipping extension installation.`);
+        ux.stdout(`${ux.colorize('dim', '--')} No extensions found or extensions file is empty. Skipping extension installation.`);
     }
-    core_1.ux.action.stop();
+    ux.action.stop();
 }
-exports.default = loadExtensions;

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

@@ -1,22 +1,19 @@
-"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 formdata_node_1 = require("formdata-node");
-const node_fs_1 = require("node:fs");
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-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 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`));
+import { readFiles, uploadFiles } from '@directus/sdk';
+import { ux } from '@oclif/core';
+import { FormData } from 'formdata-node';
+import { readFileSync } from 'node:fs';
+import path from 'pathe';
+import { DIRECTUS_PINK } from '../constants.js';
+import { api } from '../sdk.js';
+import catchError from '../utils/catch-error.js';
+import readFile from '../utils/read-file.js';
+export default async function loadFiles(dir) {
+    const files = readFile('files', dir);
+    ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading ${files.length} files`));
     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)({
+            const existingFiles = await api.client.request(readFiles({
                 fields: ['id', 'filename_disk'],
                 limit: -1,
             }));
@@ -33,9 +30,9 @@ async function loadFiles(dir) {
             });
             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();
+                const assetPath = path.resolve(dir, 'assets', fileName);
+                const fileStream = new Blob([readFileSync(assetPath)], { type: asset.type });
+                const form = new FormData();
                 form.append('id', asset.id);
                 if (asset.title)
                     form.append('title', asset.title);
@@ -45,17 +42,16 @@ async function loadFiles(dir) {
                     form.append('folder', asset.folder);
                 form.append('file', fileStream, fileName);
                 try {
-                    await sdk_2.api.client.request((0, sdk_1.uploadFiles)(form));
+                    await api.client.request(uploadFiles(form));
                 }
                 catch (error) {
-                    (0, catch_error_1.default)(error);
+                    catchError(error);
                 }
             }));
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
         }
     }
-    core_1.ux.action.stop();
+    ux.action.stop();
 }
-exports.default = loadFiles;

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

@@ -1,33 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadOperations = void 0;
-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 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`));
+import { createFlow, createOperations, readFlows, updateOperation } from '@directus/sdk';
+import { ux } from '@oclif/core';
+import { DIRECTUS_PINK } from '../constants.js';
+import { api } from '../sdk.js';
+import catchError from '../utils/catch-error.js';
+import readFile from '../utils/read-file.js';
+export default async function loadFlows(dir) {
+    const flows = readFile('flows', dir);
+    const allOperations = readFile('operations', dir);
+    ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading ${flows.length} flows`));
     if (flows && flows.length > 0) {
         try {
             // Fetch existing flows
-            const existingFlows = await sdk_2.api.client.request((0, sdk_1.readFlows)({
+            const existingFlows = await api.client.request(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 results = await Promise.allSettled(newFlows.map(flow => api.client.request(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);
+                    catchError(result.reason);
                 }
             }
             // Filter operations for newly created flows
@@ -35,36 +31,34 @@ async function loadFlows(dir) {
             await loadOperations(newOperations);
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
         }
         finally {
-            core_1.ux.action.stop();
+            ux.action.stop();
         }
     }
 }
-exports.default = loadFlows;
-async function loadOperations(operations) {
-    core_1.ux.action.status = `Loading ${operations.length} operations`;
+export async function loadOperations(operations) {
+    ux.action.status = `Loading ${operations.length} operations`;
     try {
         const opsIds = operations.map(operation => {
             const opCopy = { ...operation };
-            delete opCopy.reject;
-            delete opCopy.resolve;
+            opCopy.reject = undefined;
+            opCopy.resolve = undefined;
             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, {
+        await api.client.request(createOperations(opsIds));
+        const results = await Promise.allSettled(operations.map(operation => api.client.request(updateOperation(operation.id, {
             reject: operation.reject,
             resolve: operation.resolve,
         }))));
         for (const [index, result] of results.entries()) {
             if (result.status === 'rejected') {
-                (0, catch_error_1.default)(result.reason);
+                catchError(result.reason);
             }
         }
     }
     catch (error) {
-        (0, catch_error_1.default)(error);
+        catchError(error);
     }
 }
-exports.loadOperations = loadOperations;

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

@@ -1,19 +1,16 @@
-"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 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`));
+import { createFolders, readFolders, updateFolder } from '@directus/sdk';
+import { ux } from '@oclif/core';
+import { DIRECTUS_PINK } from '../constants.js';
+import { api } from '../sdk.js';
+import catchError from '../utils/catch-error.js';
+import readFile from '../utils/read-file.js';
+export default async function loadFolders(dir) {
+    const folders = readFile('folders', dir);
+    ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading ${folders.length} folders`));
     if (folders && folders.length > 0) {
         try {
             // Fetch existing folders
-            const existingFolders = await sdk_2.api.client.request((0, sdk_1.readFolders)({
+            const existingFolders = await api.client.request(readFolders({
                 limit: -1,
             }));
             const existingFolderIds = new Set(existingFolders.map(folder => folder.id));
@@ -26,26 +23,25 @@ async function loadFolders(dir) {
             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));
+                await api.client.request(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));
+                        await api.client.request(updateFolder(id, rest));
                     }
                     catch (error) {
-                        (0, catch_error_1.default)(error);
+                        catchError(error);
                     }
                 }));
             }
             else {
-                // ux.info('-- No new folders to create')
+                // ux.stdout('-- No new folders to create')
             }
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
         }
     }
-    core_1.ux.action.stop();
+    ux.action.stop();
 }
-exports.default = loadFolders;

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

@@ -1,31 +1,27 @@
-"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 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`));
+import { createPermissions, readPermissions } from '@directus/sdk';
+import { ux } from '@oclif/core';
+import { DIRECTUS_PINK } from '../constants.js';
+import { api } from '../sdk.js';
+import catchError from '../utils/catch-error.js';
+import readFile from '../utils/read-file.js';
+export default async function loadPermissions(dir) {
+    const permissions = readFile('permissions', dir);
+    ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading ${permissions.length} permissions`));
     if (permissions && permissions.length > 0) {
         try {
-            const existingPermissions = await sdk_2.api.client.request((0, sdk_1.readPermissions)({
+            const existingPermissions = await api.client.request(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));
+                await api.client.request(createPermissions(newPermissions));
             }
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
         }
     }
-    core_1.ux.action.stop();
+    ux.action.stop();
 }
-exports.default = loadPermissions;