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

package/dist/lib/init/index.js

@@ -0,0 +1,192 @@
+import { note, outro, spinner, log as clackLog } from '@clack/prompts';
+import { ux } from '@oclif/core';
+import { execa } from 'execa';
+import { downloadTemplate } from 'giget';
+import { glob } from 'glob';
+import fs from 'node:fs';
+import { detectPackageManager, installDependencies } from 'nypm';
+import path from 'pathe';
+import dotenv from 'dotenv';
+import terminalLink from 'terminal-link';
+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 { readTemplateConfig } from '../utils/template-config.js';
+import { DOCKER_CONFIG } from './config.js';
+import { BSL_LICENSE_TEXT, pinkText } from '../constants.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.');
+    }
+    // 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,
+        });
+        // 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 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`);
+            }
+            // 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'));
+        // Process all env files first
+        for (const file of envFiles) {
+            const envFile = file.replace('.env.example', '.env');
+            fs.copyFileSync(file, envFile);
+        }
+        // Then read Directus-specific info only from the Directus env file
+        const directusEnvFile = path.join(directusDir, '.env');
+        if (fs.existsSync(directusEnvFile)) {
+            const parsedEnv = dotenv.parse(fs.readFileSync(directusEnvFile, '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)) {
+            // Initialize Docker service
+            const dockerService = createDocker(DOCKER_CONFIG);
+            // Check if Docker is installed
+            const dockerStatus = await dockerService.checkDocker();
+            if (!dockerStatus.installed || !dockerStatus.running) {
+                throw new Error(dockerStatus.message);
+            }
+            await dockerService.startContainers(directusDir);
+            const healthCheckUrl = `${directusInfo.url || 'http://localhost:8055'}${DOCKER_CONFIG.healthCheckEndpoint}`;
+            // Wait for healthy before proceeding
+            const isHealthy = await dockerService.waitForHealthy(healthCheckUrl);
+            if (!isHealthy) {
+                throw new Error('Directus failed to become healthy');
+            }
+            const templatePath = path.join(directusDir, 'template');
+            ux.stdout(`Attempting to apply template from: ${templatePath}`);
+            await ApplyCommand.run([
+                '--directusUrl=http://localhost:8055',
+                '-p',
+                '--userEmail=admin@example.com',
+                '--userPassword=d1r3ctu5',
+                `--templateLocation=${templatePath}`,
+            ]);
+        }
+        // Install dependencies if requested
+        if (flags.installDeps) {
+            const s = spinner();
+            s.start('Installing dependencies');
+            try {
+                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;
+            }
+            s.stop('Dependencies installed!');
+        }
+        // Initialize Git repo
+        if (flags.gitInit) {
+            const s = spinner();
+            s.start('Initializing git repository');
+            await initGit(dir);
+            s.stop('Git repository initialized!');
+        }
+        // Finishing up
+        const relativeDir = path.relative(process.cwd(), dir);
+        const directusUrl = directusInfo.url ?? 'http://localhost:8055';
+        const directusText = `- Directus is running on ${terminalLink(directusUrl, directusUrl)}. You can login with the email: ${pinkText(directusInfo.email)} and password: ${pinkText(directusInfo.password)}. \n`;
+        const frontendText = flags.frontend ? `- To start the frontend, run ${pinkText(`cd ${flags.frontend}`)} and then ${pinkText(`${packageManager?.name} run dev`)}. \n` : '';
+        const projectText = `- Navigate to your project directory using ${pinkText(`cd ${relativeDir}`)}. \n`;
+        const readmeText = '- Review the \`./README.md\` file for more information and next steps.';
+        const nextSteps = `${directusText}${projectText}${frontendText}${readmeText}`;
+        note(nextSteps, 'Next Steps');
+        clackLog.warn(BSL_LICENSE_TEXT);
+        outro(`Problems or questions? Hop into the community on Discord at ${pinkText(terminalLink('https://directus.chat', 'https://directus.chat'))}`);
+    }
+    catch (error) {
+        catchError(error, {
+            context: { dir, flags, function: 'init' },
+            fatal: true,
+            logToFile: true,
+        });
+    }
+    return {
+        directusDir,
+        frontendDir: flags.frontend ? path.join(dir, flags.frontend) : undefined,
+        template,
+    };
+}
+/**
+ * Initialize a git repository
+ * @param targetDir - The directory to initialize the git repository in
+ * @returns void
+ */
+async function initGit(targetDir) {
+    try {
+        await execa('git', ['init'], { cwd: targetDir });
+    }
+    catch (error) {
+        catchError(error, {
+            context: { function: 'initGit', targetDir },
+            fatal: false,
+            logToFile: true,
+        });
+    }
+}

package/dist/lib/init/types.d.ts

@@ -0,0 +1,30 @@
+export interface InitOptions {
+    frontend?: string;
+    initGit?: boolean;
+    installDeps?: boolean;
+    programmatic?: boolean;
+    targetDir: string;
+    template: string;
+}
+export interface TemplateInfo {
+    frontends: string[];
+    hasDirectus: boolean;
+    name: string;
+}
+export interface InitResult {
+    directusUrl?: string;
+    error?: Error;
+    success: boolean;
+}
+export interface DirectusConfig {
+    adminEmail: string;
+    adminPassword: string;
+    port: number;
+    url: string;
+}
+export interface DockerConfig {
+    composeFile: string;
+    healthCheckEndpoint: string;
+    interval: number;
+    maxAttempts: number;
+}

package/dist/lib/init/types.js

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

package/dist/lib/load/apply-flags.js

@@ -1,10 +1,6 @@
-"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 = [
+import { ux } from '@oclif/core';
+import catchError from '../utils/catch-error.js';
+export const loadFlags = [
     'content',
     'dashboards',
     'extensions',
@@ -15,53 +11,51 @@ exports.loadFlags = [
     'settings',
     'users',
 ];
-function validateProgrammaticFlags(flags) {
+export function validateProgrammaticFlags(flags) {
     const { directusToken, directusUrl, templateLocation, userEmail, userPassword } = flags;
     if (!directusUrl)
-        core_1.ux.error('Directus URL is required for programmatic mode.');
+        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.');
+        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.');
+        ux.error('Template location is required for programmatic mode.');
     return flags.partial ? handlePartialFlags(flags) : setAllFlagsTrue(flags);
 }
-exports.validateProgrammaticFlags = validateProgrammaticFlags;
-function validateInteractiveFlags(flags) {
+export 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);
+    const enabledFlags = loadFlags.filter(flag => flags[flag] === true);
+    const disabledFlags = loadFlags.filter(flag => flags[flag] === false);
     if (enabledFlags.length > 0) {
-        for (const flag of exports.loadFlags)
+        for (const flag of loadFlags)
             flags[flag] = enabledFlags.includes(flag);
     }
     else if (disabledFlags.length > 0) {
-        for (const flag of exports.loadFlags)
+        for (const flag of 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 });
+    if (!loadFlags.some(flag => flags[flag])) {
+        catchError(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.');
+        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.');
+        ux.warn('User loading requires permissions. Enabling permissions flag.');
     }
 }
 function setAllFlagsTrue(flags) {
-    for (const flag of exports.loadFlags)
+    for (const flag of loadFlags)
         flags[flag] = true;
     return flags;
 }

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

@@ -1,68 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const core_1 = require("@oclif/core");
-const check_template_1 = tslib_1.__importDefault(require("../utils/check-template"));
-const load_access_1 = tslib_1.__importDefault(require("./load-access"));
-const load_collections_1 = tslib_1.__importDefault(require("./load-collections"));
-const load_dashboards_1 = tslib_1.__importDefault(require("./load-dashboards"));
-const load_data_1 = tslib_1.__importDefault(require("./load-data"));
-const load_extensions_1 = tslib_1.__importDefault(require("./load-extensions"));
-const load_files_1 = tslib_1.__importDefault(require("./load-files"));
-const load_flows_1 = tslib_1.__importDefault(require("./load-flows"));
-const load_folders_1 = tslib_1.__importDefault(require("./load-folders"));
-const load_permissions_1 = tslib_1.__importDefault(require("./load-permissions"));
-const load_policies_1 = tslib_1.__importDefault(require("./load-policies"));
-const load_presets_1 = tslib_1.__importDefault(require("./load-presets"));
-const load_relations_1 = tslib_1.__importDefault(require("./load-relations"));
-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);
+import { ux } from '@oclif/core';
+import checkTemplate from '../utils/check-template.js';
+import loadAccess from './load-access.js';
+import loadCollections from './load-collections.js';
+import loadDashboards from './load-dashboards.js';
+import loadData from './load-data.js';
+import loadExtensions from './load-extensions.js';
+import loadFiles from './load-files.js';
+import loadFlows from './load-flows.js';
+import loadFolders from './load-folders.js';
+import loadPermissions from './load-permissions.js';
+import loadPolicies from './load-policies.js';
+import loadPresets from './load-presets.js';
+import loadRelations from './load-relations.js';
+import loadRoles from './load-roles.js';
+import loadSettings from './load-settings.js';
+import loadTranslations from './load-translations.js';
+import loadUsers from './load-users.js';
+import updateRequiredFields from './update-required-fields.js';
+export default async function apply(dir, flags) {
+    const source = `${dir}/src`;
+    const isTemplateOk = await checkTemplate(source);
     if (!isTemplateOk) {
-        core_1.ux.error('The template is missing the collections, fields, or relations files. Older templates are not supported in v0.4 of directus-template-cli. Try using v0.3 to load older templates npx directus-template-cli@0.3 apply or extract the template using latest version before applying. Exiting...');
+        ux.error('The template is missing the collections, fields, or relations files. Older templates are not supported in v0.4 of directus-template-cli. Try using v0.3 to load older templates npx directus-template-cli@0.3 apply or extract the template using latest version before applying. Exiting...');
     }
     if (flags.schema) {
-        await (0, load_collections_1.default)(source);
-        await (0, load_relations_1.default)(source);
+        await loadCollections(source);
+        await loadRelations(source);
     }
     if (flags.permissions || flags.users) {
-        await (0, load_roles_1.default)(source);
-        await (0, load_policies_1.default)(source);
-        await (0, load_permissions_1.default)(source);
+        await loadRoles(source);
+        await loadPolicies(source);
+        await loadPermissions(source);
         if (flags.users) {
-            await (0, load_users_1.default)(source);
+            await loadUsers(source);
         }
-        await (0, load_access_1.default)(source);
+        await loadAccess(source);
     }
     if (flags.files) {
-        await (0, load_folders_1.default)(source);
-        await (0, load_files_1.default)(source);
+        await loadFolders(source);
+        await loadFiles(source);
     }
     if (flags.content) {
-        await (0, load_data_1.default)(source);
+        await loadData(source);
     }
     if (flags.schema) {
-        await (0, update_required_fields_1.default)(source);
+        await updateRequiredFields(source);
     }
     if (flags.dashboards) {
-        await (0, load_dashboards_1.default)(source);
+        await loadDashboards(source);
     }
     if (flags.flows) {
-        await (0, load_flows_1.default)(source);
+        await loadFlows(source);
     }
     if (flags.settings) {
-        await (0, load_settings_1.default)(source);
-        await (0, load_translations_1.default)(source);
-        await (0, load_presets_1.default)(source);
+        await loadSettings(source);
+        await loadTranslations(source);
+        await loadPresets(source);
     }
     if (flags.extensions) {
-        await (0, load_extensions_1.default)(source);
+        await loadExtensions(source);
     }
     return {};
 }
-exports.default = apply;

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

@@ -1,25 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-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`));
+import { ux } from '@oclif/core';
+import { DIRECTUS_PINK } from '../constants.js';
+import { api } from '../sdk.js';
+import catchError from '../utils/catch-error.js';
+import getRoleIds from '../utils/get-role-ids.js';
+import readFile from '../utils/read-file.js';
+export default async function loadAccess(dir) {
+    const access = readFile('access', dir);
+    ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading ${access.length} accesses`));
     if (access && access.length > 0) {
         // Fetch existing accesses
-        const existingAccesses = await sdk_1.api.client.request(() => ({
+        const existingAccesses = await api.client.request(() => ({
             method: 'GET',
             params: {
                 limit: -1,
             },
             path: '/access',
         }));
-        const { legacyAdminRoleId, newAdminRoleId } = await (0, get_role_ids_1.default)(dir);
+        const { legacyAdminRoleId, newAdminRoleId } = await getRoleIds(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) {
@@ -39,7 +36,7 @@ async function loadAccess(dir) {
                 if (acc.role === legacyAdminRoleId) {
                     acc.role = newAdminRoleId;
                 }
-                await sdk_1.api.client.request(() => ({
+                await api.client.request(() => ({
                     body: JSON.stringify(acc),
                     method: 'POST',
                     path: '/access',
@@ -49,7 +46,7 @@ async function loadAccess(dir) {
                 existingAccessByCompositeKey.set(compositeKey, acc);
             }
             catch (error) {
-                (0, catch_error_1.default)(error, {
+                catchError(error, {
                     context: {
                         access: acc,
                         operation: 'createAccess',
@@ -58,11 +55,9 @@ async function loadAccess(dir) {
             }
         }
     }
-    core_1.ux.action.stop();
+    ux.action.stop();
 }
-exports.default = loadAccess;
 // Helper function to generate a composite key for each access
 function getCompositeKey(acc) {
-    var _a, _b;
-    return `${(_a = acc.role) !== null && _a !== void 0 ? _a : 'null'}-${(_b = acc.user) !== null && _b !== void 0 ? _b : 'null'}-${acc.policy}`;
+    return `${acc.role ?? 'null'}-${acc.user ?? 'null'}-${acc.policy}`;
 }

package/dist/lib/load/load-collections.d.ts

@@ -1,4 +1,6 @@
 /**
  * Load collections into the Directus instance
+ * @param dir - The directory to read the collections and fields from
+ * @returns {Promise<void>} - Returns nothing
  */
 export default function loadCollections(dir: string): Promise<void>;

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

@@ -1,48 +1,45 @@
-"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 { createCollection, createField, readCollections, readFields, updateCollection, } 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';
 /**
  * Load collections into the Directus instance
+ * @param dir - The directory to read the collections and fields from
+ * @returns {Promise<void>} - Returns nothing
  */
-async function loadCollections(dir) {
-    const collectionsToAdd = (0, read_file_1.default)('collections', dir);
-    const fieldsToAdd = (0, read_file_1.default)('fields', dir);
-    core_1.ux.action.start(core_1.ux.colorize(constants_1.DIRECTUS_PINK, `Loading ${collectionsToAdd.length} collections and ${fieldsToAdd.length} fields`));
+export default async function loadCollections(dir) {
+    const collectionsToAdd = readFile('collections', dir);
+    const fieldsToAdd = readFile('fields', dir);
+    ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading ${collectionsToAdd.length} collections and ${fieldsToAdd.length} fields`));
     await processCollections(collectionsToAdd, fieldsToAdd);
     await updateCollections(collectionsToAdd);
     await addCustomFieldsOnSystemCollections(fieldsToAdd);
-    core_1.ux.action.stop();
+    ux.action.stop();
 }
-exports.default = loadCollections;
 async function processCollections(collectionsToAdd, fieldsToAdd) {
-    const existingCollections = await sdk_2.api.client.request((0, sdk_1.readCollections)());
-    const existingFields = await sdk_2.api.client.request((0, sdk_1.readFields)());
+    const existingCollections = await api.client.request(readCollections());
+    const existingFields = await api.client.request(readFields());
     for await (const collection of collectionsToAdd) {
         try {
             const existingCollection = existingCollections.find((c) => c.collection === collection.collection);
             await (existingCollection ? addNewFieldsToExistingCollection(collection.collection, fieldsToAdd, existingFields) : addNewCollectionWithFields(collection, fieldsToAdd));
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
         }
     }
 }
 const removeRequiredorIsNullable = (field) => {
-    var _a, _b, _c;
-    if (((_a = field.meta) === null || _a === void 0 ? void 0 : _a.required) === true) {
+    if (field.meta?.required === true) {
         field.meta.required = false;
     }
-    if (((_b = field.schema) === null || _b === void 0 ? void 0 : _b.is_nullable) === false) {
+    if (field.schema?.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) {
+    if (field.schema?.is_unique === true) {
         // eslint-disable-next-line camelcase
         field.schema.is_unique = false;
     }
@@ -57,7 +54,7 @@ async function addNewCollectionWithFields(collection, allFields) {
         meta: { ...collection.meta },
     };
     delete collectionWithoutGroup.meta.group;
-    await sdk_2.api.client.request((0, sdk_1.createCollection)(collectionWithoutGroup));
+    await api.client.request(createCollection(collectionWithoutGroup));
 }
 async function addNewFieldsToExistingCollection(collectionName, fieldsToAdd, existingFields) {
     const collectionFieldsToAdd = fieldsToAdd.filter(field => field.collection === collectionName)
@@ -66,11 +63,11 @@ async function addNewFieldsToExistingCollection(collectionName, fieldsToAdd, exi
     for await (const field of collectionFieldsToAdd) {
         if (!existingCollectionFields.some((existingField) => existingField.field === field.field)) {
             try {
-                // @ts-ignore
-                await sdk_2.api.client.request((0, sdk_1.createField)(collectionName, field));
+                // @ts-ignore - ignore
+                await api.client.request(createField(collectionName, field));
             }
             catch (error) {
-                (0, catch_error_1.default)(error);
+                catchError(error);
             }
         }
     }
@@ -84,27 +81,27 @@ async function updateCollections(collections) {
                         group: collection.meta.group,
                     },
                 };
-                await sdk_2.api.client.request((0, sdk_1.updateCollection)(collection.collection, pl));
+                await api.client.request(updateCollection(collection.collection, pl));
             }
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
         }
     }
 }
 async function addCustomFieldsOnSystemCollections(fields) {
     const customFields = fields.filter((field) => field.collection.startsWith('directus_'));
-    const existingFields = await sdk_2.api.client.request((0, sdk_1.readFields)());
+    const existingFields = await api.client.request(readFields());
     for await (const field of customFields) {
         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));
+                // @ts-ignore
+                await api.client.request(createField(field.collection, field));
             }
         }
         catch (error) {
-            (0, catch_error_1.default)(error);
+            catchError(error);
         }
     }
 }