directus-template-cli 0.7.8 → 0.8.0

package/dist/commands/init.js

@@ -62,76 +62,67 @@ export default class InitCommand extends BaseCommand {
      * @returns Promise that resolves when the command is complete.
      */
     async run() {
-        const { args, flags } = await this.parse(InitCommand);
+        const { args, flags, metadata } = await this.parse(InitCommand);
         const typedFlags = flags;
         const typedArgs = args;
+        const explicitFlags = {
+            gitInit: !metadata.flags.gitInit?.setFromDefault,
+            installDeps: !metadata.flags.installDeps?.setFromDefault,
+        };
         // Set the target directory and create it if it doesn't exist
         this.targetDir = path.resolve(args.directory);
-        await this.runInteractive(typedFlags, typedArgs);
+        await this.runInteractive(typedFlags, typedArgs, explicitFlags);
     }
-    /**
-     * Interactive mode: prompts the user for each piece of info, with added template checks.
-     * @param flags - The flags passed to the command.
-     * @param args - The arguments passed to the command.
-     * @returns void
-     */
-    async runInteractive(flags, args) {
-        // Show animated intro
-        await animatedBunny('Let\'s create a new Directus project!');
-        intro(`${chalk.bgHex(DIRECTUS_PURPLE).white.bold('Directus Template CLI')} - Create Project`);
-        // Check Docker availability before proceeding
-        const { createDocker } = await import('../services/docker.js');
-        const { DOCKER_CONFIG } = await import('../lib/init/config.js');
-        const dockerService = createDocker(DOCKER_CONFIG);
-        const dockerStatus = await dockerService.checkDocker();
-        if (!dockerStatus.installed || !dockerStatus.running) {
-            cancel(dockerStatus.message || 'Docker is required to initialize a Directus project.');
-            process.exit(1);
+    async confirmBooleanFlag(message) {
+        const response = await confirm({
+            initialValue: true,
+            message,
+        });
+        if (isCancel(response)) {
+            cancel('Project creation cancelled.');
+            process.exit(0);
         }
-        // Create GitHub service
-        const github = createGitHub();
-        // If no dir is provided, ask for it
-        if (!args.directory || args.directory === '.') {
-            let dirResponse = await text({
-                message: 'Enter the directory to create the project in:',
-                placeholder: './my-directus-project',
-            });
-            if (isCancel(dirResponse)) {
-                cancel('Project creation cancelled.');
-                process.exit(0);
-            }
-            // If there's no response, set a default
-            if (!dirResponse) {
-                clackLog.warn('No directory provided, using default: ./my-directus-project');
-                dirResponse = './my-directus-project';
-            }
-            this.targetDir = dirResponse;
+        return response;
+    }
+    async confirmOverwriteDirectory(flags) {
+        if (!fs.existsSync(this.targetDir) || flags.overwriteDir)
+            return Boolean(flags.overwriteDir);
+        const overwriteDirResponse = await confirm({
+            initialValue: false,
+            message: 'Directory already exists. Would you like to overwrite it?',
+        });
+        if (isCancel(overwriteDirResponse) || overwriteDirResponse === false) {
+            cancel('Project creation cancelled.');
+            process.exit(0);
         }
-        if (fs.existsSync(this.targetDir) && !flags.overwriteDir) {
-            const overwriteDirResponse = await confirm({
-                initialValue: false,
-                message: 'Directory already exists. Would you like to overwrite it?',
-            });
-            if (isCancel(overwriteDirResponse) || overwriteDirResponse === false) {
-                cancel('Project creation cancelled.');
-                process.exit(0);
-            }
-            if (overwriteDirResponse) {
-                flags.overwriteDir = true;
-            }
+        return true;
+    }
+    async promptForTargetDirectory(args) {
+        if (args.directory && args.directory !== '.')
+            return;
+        let dirResponse = await text({
+            message: 'Enter the directory to create the project in:',
+            placeholder: './my-directus-project',
+        });
+        if (isCancel(dirResponse)) {
+            cancel('Project creation cancelled.');
+            process.exit(0);
         }
-        // 1. Fetch available templates (now returns Array<{id: string, name: string, description?: string}>)
-        const availableTemplates = await github.getTemplates();
-        // 2. Prompt for template if not provided
-        let { template } = flags; // This will store the chosen template ID
-        let chosenTemplateObject;
+        // If there's no response, set a default
+        if (!dirResponse) {
+            clackLog.warn('No directory provided, using default: ./my-directus-project');
+            dirResponse = './my-directus-project';
+        }
+        this.targetDir = dirResponse;
+    }
+    async promptForValidTemplate(template, availableTemplates) {
         if (!template) {
             const templateResponse = await select({
                 message: 'Which Directus backend template would you like to use?',
                 options: availableTemplates.map(tmpl => ({
-                    hint: tmpl.description, // Show the description as a hint
-                    label: tmpl.name, // Display the friendly name
-                    value: tmpl.id, // The value submitted will be the ID (directory name)
+                    hint: tmpl.description,
+                    label: tmpl.name,
+                    value: tmpl.id,
                 })),
             });
             if (isCancel(templateResponse)) {
@@ -140,14 +131,9 @@ export default class InitCommand extends BaseCommand {
             }
             template = templateResponse;
         }
-        // Find the chosen template object for potential future use (e.g., display name later)
-        chosenTemplateObject = availableTemplates.find(t => t.id === template);
-        // 3. Validate that the template exists in the available list
-        const isDirectUrl = template?.startsWith('http');
-        // Validate against the 'id' property of the template objects
-        while (!isDirectUrl && !availableTemplates.some(t => t.id === template)) {
-            // Keep the warning message simple or refer back to the list shown in the prompt
+        while (!template.startsWith('http') && !availableTemplates.some(t => t.id === template)) {
             clackLog.warn(`Template ID "${template}" is not valid. Please choose from the list provided or enter a direct GitHub URL.`);
+            // eslint-disable-next-line no-await-in-loop
             const templateNameResponse = await text({
                 message: 'Please enter a valid template ID, a direct GitHub URL, or Ctrl+C to cancel:',
             });
@@ -156,8 +142,37 @@ export default class InitCommand extends BaseCommand {
                 process.exit(0);
             }
             template = templateNameResponse;
-            chosenTemplateObject = availableTemplates.find(t => t.id === template); // Update chosen object after re-entry
         }
+        return template;
+    }
+    /**
+     * Interactive mode: prompts the user for each piece of info, with added template checks.
+     * @param flags - The flags passed to the command.
+     * @param args - The arguments passed to the command.
+     * @returns void
+     */
+    async runInteractive(flags, args, explicitFlags) {
+        // Show animated intro
+        await animatedBunny('Let\'s create a new Directus project!');
+        intro(`${chalk.bgHex(DIRECTUS_PURPLE).white.bold('Directus Template CLI')} - Create Project`);
+        // Check Docker availability before proceeding
+        const { createDocker } = await import('../services/docker.js');
+        const { DOCKER_CONFIG } = await import('../lib/init/config.js');
+        const dockerService = createDocker(DOCKER_CONFIG);
+        const dockerStatus = await dockerService.checkDocker();
+        if (!dockerStatus.installed || !dockerStatus.running) {
+            cancel(dockerStatus.message || 'Docker is required to initialize a Directus project.');
+            process.exit(1);
+        }
+        // Create GitHub service
+        const github = createGitHub();
+        // If no dir is provided, ask for it
+        await this.promptForTargetDirectory(args);
+        const overwriteDir = await this.confirmOverwriteDirectory(flags);
+        // 1. Fetch available templates (now returns Array<{id: string, name: string, description?: string}>)
+        const availableTemplates = await github.getTemplates();
+        // 2. Prompt for template if not provided, then validate it against known templates or a direct URL.
+        const template = await this.promptForValidTemplate(flags.template, availableTemplates);
         flags.template = template; // Ensure the flag stores the ID
         // Download the template to a temporary directory to read its configuration
         const tempDir = path.join(os.tmpdir(), `directus-template-${Date.now()}`);
@@ -170,7 +185,7 @@ export default class InitCommand extends BaseCommand {
             // Read template configuration
             const templateInfo = readTemplateConfig(tempDir);
             // 4. If template has frontends and user hasn't specified a valid one, ask from the list
-            if (templateInfo?.frontendOptions.length > 0 && (!chosenFrontend || !templateInfo.frontendOptions.find(f => f.id === chosenFrontend))) {
+            if (templateInfo?.frontendOptions.length > 0 && (!chosenFrontend || !templateInfo.frontendOptions.some(f => f.id === chosenFrontend))) {
                 const frontendResponse = await select({
                     message: 'Which frontend framework do you want to use?',
                     options: templateInfo.frontendOptions.map(frontend => ({
@@ -194,24 +209,12 @@ export default class InitCommand extends BaseCommand {
                 fs.rmSync(tempDir, { force: true, recursive: true });
             }
         }
-        const installDepsResponse = await confirm({
-            initialValue: true,
-            message: 'Would you like to install project dependencies automatically?',
-        });
-        if (isCancel(installDepsResponse)) {
-            cancel('Project creation cancelled.');
-            process.exit(0);
-        }
-        const installDeps = installDepsResponse;
-        const initGitResponse = await confirm({
-            initialValue: true,
-            message: 'Initialize a new Git repository?',
-        });
-        if (isCancel(initGitResponse)) {
-            cancel('Project creation cancelled.');
-            process.exit(0);
-        }
-        const initGit = initGitResponse;
+        const installDeps = explicitFlags.installDeps
+            ? flags.installDeps ?? true
+            : await this.confirmBooleanFlag('Would you like to install project dependencies automatically?');
+        const initGit = explicitFlags.gitInit
+            ? flags.gitInit ?? true
+            : await this.confirmBooleanFlag('Initialize a new Git repository?');
         // Track the command start unless telemetry is disabled
         if (!flags.disableTelemetry) {
             await track({
@@ -235,7 +238,7 @@ export default class InitCommand extends BaseCommand {
                 frontend: chosenFrontend,
                 gitInit: initGit,
                 installDeps,
-                overwriteDir: flags.overwriteDir,
+                overwriteDir,
                 template,
             },
         });
@@ -249,7 +252,7 @@ export default class InitCommand extends BaseCommand {
                     frontend: chosenFrontend,
                     gitInit: initGit,
                     installDeps,
-                    overwriteDir: flags.overwriteDir,
+                    overwriteDir,
                     template,
                 },
                 lifecycle: 'complete',

package/dist/lib/extract/expand-deep-plan.d.ts

@@ -0,0 +1,2 @@
+import { type TemplatePlan } from '../template-plan/index.js';
+export declare function expandDeepPlan(plan: TemplatePlan): Promise<TemplatePlan>;

package/dist/lib/extract/expand-deep-plan.js

@@ -0,0 +1,54 @@
+import { readCollections, readRelations } from '@directus/sdk';
+import { ux } from '@oclif/core';
+import { api } from '../sdk.js';
+import { includesCollection } from '../template-plan/index.js';
+export async function expandDeepPlan(plan) {
+    if (!plan.partial || plan.relationStrategy !== 'deep' || !plan.collections)
+        return plan;
+    const collections = await api.client.request(readCollections());
+    const availableCollections = collections
+        .filter((collection) => !collection.collection.startsWith('directus_', 0))
+        .filter((collection) => collection.schema !== null)
+        .map((collection) => collection.collection)
+        .filter((collection) => includesCollection(collection, { ...plan, collections: undefined }));
+    const available = new Set(availableCollections);
+    const missingCollections = plan.collections.filter((collection) => !available.has(collection));
+    if (missingCollections.length > 0) {
+        ux.warn(`Requested collections not found or excluded: ${missingCollections.join(', ')}`);
+    }
+    const selected = new Set(plan.collections.filter((collection) => available.has(collection)));
+    const relations = (await api.client.request(readRelations()));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const candidates = [];
+        for (const relation of relations) {
+            if (selected.has(relation.collection) && relation.related_collection) {
+                candidates.push(relation.related_collection);
+            }
+            if (relation.related_collection && selected.has(relation.related_collection)) {
+                candidates.push(relation.collection);
+            }
+            if (selected.has(relation.collection) && relation.meta?.one_allowed_collections) {
+                candidates.push(...relation.meta.one_allowed_collections);
+            }
+        }
+        for (const collection of candidates) {
+            if (!available.has(collection))
+                continue;
+            if (selected.has(collection))
+                continue;
+            selected.add(collection);
+            changed = true;
+        }
+    }
+    const expandedCollections = [...selected];
+    const addedCollections = expandedCollections.filter((collection) => !plan.collections?.includes(collection));
+    if (addedCollections.length > 0) {
+        ux.warn(`Deep relation strategy expanded collections: ${addedCollections.join(', ')}`);
+    }
+    return {
+        ...plan,
+        collections: expandedCollections,
+    };
+}

package/dist/lib/extract/expand-schema-plan.d.ts

@@ -0,0 +1,2 @@
+import { type TemplatePlan } from '../template-plan/index.js';
+export declare function expandSchemaPlan(plan: TemplatePlan): Promise<TemplatePlan>;

package/dist/lib/extract/expand-schema-plan.js

@@ -0,0 +1,55 @@
+import { readCollections, readRelations } from '@directus/sdk';
+import { ux } from '@oclif/core';
+import { api } from '../sdk.js';
+import { includesCollection } from '../template-plan/index.js';
+export async function expandSchemaPlan(plan) {
+    if (!plan.partial || !plan.collections)
+        return plan;
+    const collections = (await api.client.request(readCollections()));
+    const availableCollections = collections
+        .filter((collection) => !collection.collection.startsWith('directus_', 0))
+        .map((collection) => collection.collection)
+        .filter((collection) => includesCollection(collection, { ...plan, collections: undefined }));
+    const collectionMap = new Map(collections.map((collection) => [collection.collection, collection]));
+    const available = new Set(availableCollections);
+    const selected = new Set(plan.collections.filter((collection) => available.has(collection)));
+    const relations = (await api.client.request(readRelations()));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const candidates = [];
+        for (const collection of selected) {
+            const group = collectionMap.get(collection)?.meta?.group;
+            if (group)
+                candidates.push(group);
+        }
+        for (const relation of relations) {
+            if (selected.has(relation.collection) && relation.related_collection) {
+                candidates.push(relation.related_collection);
+            }
+            if (relation.related_collection && selected.has(relation.related_collection)) {
+                candidates.push(relation.collection);
+            }
+            if (selected.has(relation.collection) && relation.meta?.one_allowed_collections) {
+                candidates.push(...relation.meta.one_allowed_collections);
+            }
+        }
+        for (const collection of candidates) {
+            if (!available.has(collection))
+                continue;
+            if (selected.has(collection))
+                continue;
+            selected.add(collection);
+            changed = true;
+        }
+    }
+    const schemaCollections = [...selected];
+    const addedCollections = schemaCollections.filter((collection) => !plan.collections?.includes(collection));
+    if (addedCollections.length > 0) {
+        ux.warn(`Schema scope expanded collections: ${addedCollections.join(', ')}`);
+    }
+    return {
+        ...plan,
+        schemaCollections,
+    };
+}

package/dist/lib/extract/extract-assets.js

@@ -5,10 +5,13 @@ import path from 'pathe';
 import { DIRECTUS_PINK } from '../constants.js';
 import { api } from '../sdk.js';
 import catchError from '../utils/catch-error.js';
-async function getAssetList() {
-    return api.client.request(readFiles({ limit: -1 }));
+// Keep asset pages conservative because each item may trigger a binary download.
+const PAGE_SIZE = 100;
+async function getAssetPage(page) {
+    return api.client.request(readFiles({ limit: PAGE_SIZE, page }));
 }
 async function downloadFile(file, dir) {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
     const response = await api.client.request(() => ({
         method: 'GET',
         path: `/assets/${file.id}`,
@@ -29,10 +32,20 @@ export async function downloadAllFiles(dir) {
         if (path && !fs.existsSync(fullPath)) {
             fs.mkdirSync(fullPath, { recursive: true });
         }
-        const fileList = await getAssetList();
-        await Promise.all(fileList.map(file => downloadFile(file, dir).catch(error => {
-            catchError(`Error downloading ${file.filename_disk}: ${error.message}`);
-        })));
+        let page = 1;
+        while (true) {
+            ux.action.status = `Downloading assets page ${page}`;
+            // Page asset metadata sequentially and finish each page before fetching the next, to avoid queuing all downloads at once.
+            // eslint-disable-next-line no-await-in-loop
+            const fileList = await getAssetPage(page);
+            // eslint-disable-next-line no-await-in-loop
+            await Promise.all(fileList.map((file) => downloadFile(file, dir).catch((error) => {
+                catchError(`Error downloading ${file.filename_disk}: ${error.message}`);
+            })));
+            if (fileList.length < PAGE_SIZE)
+                break;
+            page++;
+        }
     }
     catch (error) {
         catchError(error);

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

@@ -1,4 +1,5 @@
+import { type TemplatePlan } from '../template-plan/index.js';
 /**
  * Extract collections from the Directus instance
  */
-export default function extractCollections(dir: string): Promise<void>;
+export default function extractCollections(dir: string, plan?: TemplatePlan): Promise<void>;

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

@@ -2,16 +2,19 @@ import { readCollections } from '@directus/sdk';
 import { ux } from '@oclif/core';
 import { DIRECTUS_PINK } from '../constants.js';
 import { api } from '../sdk.js';
+import { includesSchemaCollection } from '../template-plan/index.js';
 import catchError from '../utils/catch-error.js';
 import writeToFile from '../utils/write-to-file.js';
 /**
  * Extract collections from the Directus instance
  */
-export default async function extractCollections(dir) {
+export default async function extractCollections(dir, plan) {
     ux.action.start(ux.colorize(DIRECTUS_PINK, 'Extracting collections'));
     try {
         const response = await api.client.request(readCollections());
-        const collections = response.filter(collection => !collection.collection.startsWith('directus_'));
+        const collections = response
+            .filter((collection) => !collection.collection.startsWith('directus_'))
+            .filter((collection) => includesSchemaCollection(collection.collection, plan));
         await writeToFile('collections', collections, dir);
     }
     catch (error) {

package/dist/lib/extract/extract-content.d.ts

@@ -1 +1,2 @@
-export declare function extractContent(dir: string): Promise<void>;
+import { type TemplatePlan, type TemplateWarning } from '../template-plan/index.js';
+export declare function extractContent(dir: string, plan?: TemplatePlan): Promise<TemplateWarning[]>;

package/dist/lib/extract/extract-content.js

@@ -1,33 +1,128 @@
-import { readCollections, readItems } from '@directus/sdk';
-import { ux } from '@oclif/core';
+import { readCollections, readItems, readRelations } from '@directus/sdk';
+import { Errors, ux } from '@oclif/core';
 import { DIRECTUS_PINK } from '../constants.js';
 import { api } from '../sdk.js';
+import { getBrokenJunctionCollections, includesCollection, } from '../template-plan/index.js';
 import catchError from '../utils/catch-error.js';
 import writeToFile from '../utils/write-to-file.js';
-async function getCollections() {
+// Content items are JSON-only, so pages can be larger than asset download pages.
+const PAGE_SIZE = 500;
+async function getCollections(relations, plan) {
     const response = await api.client.request(readCollections());
+    const brokenJunctions = getBrokenJunctionCollections(relations, plan);
     return response
-        .filter(item => !item.collection.startsWith('directus_', 0))
-        .filter(item => item.schema != null)
-        .map(i => i.collection);
+        .filter((item) => !item.collection.startsWith('directus_', 0))
+        .filter((item) => item.schema !== null)
+        .map((i) => i.collection)
+        .filter((collection) => includesCollection(collection, plan))
+        .filter((collection) => !brokenJunctions.has(collection));
 }
-async function getDataFromCollection(collection, dir) {
+async function getCollectionItems(collection) {
+    const items = [];
+    let page = 1;
+    while (true) {
+        // eslint-disable-next-line no-await-in-loop
+        const response = (await api.client.request(readItems(collection, { limit: PAGE_SIZE, page })));
+        items.push(...response);
+        if (response.length < PAGE_SIZE)
+            break;
+        page++;
+    }
+    return items;
+}
+function getExcludedRelationFields(collection, relations, plan) {
+    if (!plan?.partial || plan.relationStrategy === 'deep')
+        return [];
+    const m2oFields = relations
+        .filter((relation) => relation.collection === collection)
+        .filter((relation) => Boolean(relation.related_collection))
+        .filter((relation) => !includesCollection(relation.related_collection, plan))
+        .map((relation) => ({
+        field: relation.field,
+        relatedCollection: relation.related_collection,
+        type: 'm2o',
+    }));
+    const aliasFields = relations
+        .filter((relation) => relation.related_collection === collection)
+        .filter((relation) => Boolean(relation.meta?.one_field))
+        .filter((relation) => !includesCollection(relation.collection, plan))
+        .map((relation) => ({
+        field: relation.meta.one_field,
+        relatedCollection: relation.collection,
+        type: 'alias',
+    }));
+    return [...m2oFields, ...aliasFields];
+}
+function hasValue(value) {
+    if (Array.isArray(value))
+        return value.length > 0;
+    return value !== null && value !== undefined;
+}
+function emptyExcludedRelations(items, relations) {
+    for (const item of items) {
+        for (const relation of relations) {
+            if (!(relation.field in item))
+                continue;
+            if (relation.type === 'alias') {
+                delete item[relation.field];
+            }
+            else {
+                item[relation.field] = null;
+            }
+        }
+    }
+}
+function getBrokenRelationWarnings(collection, items, relations) {
+    return relations
+        .map((relation) => ({
+        collection,
+        count: items.filter((item) => hasValue(item[relation.field])).length,
+        field: relation.field,
+        relatedCollection: relation.relatedCollection,
+        type: 'excluded_relation',
+    }))
+        .filter((warning) => warning.count > 0);
+}
+async function getDataFromCollection(collection, dir, relations, plan) {
     try {
-        const response = await api.client.request(readItems(collection, { limit: -1 }));
+        ux.action.status = `Extracting content: ${collection}`;
+        const response = await getCollectionItems(collection);
+        const excludedRelations = getExcludedRelationFields(collection, relations, plan);
+        if (plan?.relationStrategy === 'empty') {
+            emptyExcludedRelations(response, excludedRelations);
+        }
+        const warnings = plan?.relationStrategy === 'preserve' ? getBrokenRelationWarnings(collection, response, excludedRelations) : [];
         await writeToFile(`${collection}`, response, `${dir}/content/`);
+        return warnings;
     }
     catch (error) {
-        catchError(error);
+        catchError(error, {
+            context: { collection, function: 'getDataFromCollection' },
+            fatal: true,
+        });
     }
 }
-export async function extractContent(dir) {
+export async function extractContent(dir, plan) {
     ux.action.start(ux.colorize(DIRECTUS_PINK, 'Extracting content'));
+    const warnings = [];
     try {
-        const collections = await getCollections();
-        await Promise.all(collections.map(collection => getDataFromCollection(collection, dir)));
+        const relations = (await api.client.request(readRelations()));
+        const collections = await getCollections(relations, plan);
+        for (const collection of collections) {
+            // Keep extraction sequential so the shared ux.action.status reflects the active collection.
+            // eslint-disable-next-line no-await-in-loop
+            const collectionWarnings = await getDataFromCollection(collection, dir, relations, plan);
+            warnings.push(...collectionWarnings);
+        }
     }
     catch (error) {
-        catchError(error);
+        if (error instanceof Errors.CLIError)
+            throw error;
+        catchError(error, {
+            context: { function: 'extractContent' },
+            fatal: true,
+        });
     }
     ux.action.stop();
+    return warnings;
 }

package/dist/lib/extract/extract-fields.d.ts

@@ -1,4 +1,5 @@
+import { type TemplatePlan } from '../template-plan/index.js';
 /**
  * Extract fields from the Directus instance
  */
-export default function extractFields(dir: string): Promise<void>;
+export default function extractFields(dir: string, plan?: TemplatePlan): Promise<void>;

package/dist/lib/extract/extract-fields.js

@@ -2,12 +2,13 @@ import { readFields } from '@directus/sdk';
 import { ux } from '@oclif/core';
 import { DIRECTUS_PINK } from '../constants.js';
 import { api } from '../sdk.js';
+import { includesSchemaCollection } from '../template-plan/index.js';
 import catchError from '../utils/catch-error.js';
 import writeToFile from '../utils/write-to-file.js';
 /**
  * Extract fields from the Directus instance
  */
-export default async function extractFields(dir) {
+export default async function extractFields(dir, plan) {
     ux.action.start(ux.colorize(DIRECTUS_PINK, 'Extracting fields'));
     try {
         const response = await api.client.request(readFields());
@@ -15,10 +16,9 @@ export default async function extractFields(dir) {
             throw new TypeError('Unexpected response format');
         }
         const fields = response
-            .filter(
-        // @ts-ignore
-        (i) => i.meta && !i.meta.system)
-            .map(i => {
+            .filter((i) => i.meta && !i.meta.system)
+            .filter((i) => includesSchemaCollection(i.collection, plan))
+            .map((i) => {
             if (i.meta) {
                 delete i.meta.id;
             }

package/dist/lib/extract/extract-relations.d.ts

@@ -1,4 +1,5 @@
+import { type TemplatePlan } from '../template-plan/index.js';
 /**
  * Extract relations from the Directus instance
  */
-export default function extractRelations(dir: string): Promise<void>;
+export default function extractRelations(dir: string, plan?: TemplatePlan): Promise<void>;