directus-template-cli 0.7.6 → 0.8.0-partials.0

package/dist/lib/load/index.js

@@ -1,5 +1,8 @@
 import { ux } from '@oclif/core';
+import { applyMetadataToPlan, buildTemplatePlan, readTemplateMetadata } from '../template-plan/index.js';
 import checkTemplate from '../utils/check-template.js';
+import finalizeCollections from './finalize-collections.js';
+import finalizeFields from './finalize-fields.js';
 import loadAccess from './load-access.js';
 import loadCollections from './load-collections.js';
 import loadDashboards from './load-dashboards.js';
@@ -16,48 +19,62 @@ 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) {
-        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...');
+    const metadata = readTemplateMetadata(source);
+    const requestedPlan = buildTemplatePlan(flags);
+    const effectivePlan = applyMetadataToPlan(requestedPlan, metadata);
+    const { components } = effectivePlan;
+    if (!metadata) {
+        ux.warn('No template-meta.json found. Treating as a full template — relation integrity check skipped.');
     }
-    if (flags.schema) {
-        await loadCollections(source);
-        await loadRelations(source);
+    else if (metadata.partial) {
+        ux.warn('Template metadata indicates this is a partial template.');
     }
-    if (flags.permissions || flags.users) {
+    const brokenRelationWarnings = metadata?.warnings?.filter((warning) => warning.type === 'excluded_relation') || [];
+    if (components.content && brokenRelationWarnings.length > 0 && !effectivePlan.allowBrokenRelations) {
+        ux.error('This partial template contains excluded relation references. Re-run with --allow-broken-relations to apply anyway.');
+    }
+    if (!metadata || components.schema) {
+        const isTemplateOk = await checkTemplate(source);
+        if (!isTemplateOk) {
+            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 (components.schema) {
+        await loadCollections(source, effectivePlan);
+        await loadRelations(source, effectivePlan);
+        await finalizeCollections(source, effectivePlan);
+        await finalizeFields(source, effectivePlan);
+    }
+    if (components.permissions || components.users) {
         await loadRoles(source);
         await loadPolicies(source);
         await loadPermissions(source);
-        if (flags.users) {
+        if (components.users) {
             await loadUsers(source);
         }
         await loadAccess(source);
     }
-    if (flags.files) {
+    if (components.files) {
         await loadFolders(source);
         await loadFiles(source);
     }
-    if (flags.content) {
-        await loadData(source);
-    }
-    if (flags.schema) {
-        await updateRequiredFields(source);
+    if (components.content) {
+        await loadData(source, effectivePlan);
     }
-    if (flags.dashboards) {
+    if (components.dashboards) {
         await loadDashboards(source);
     }
-    if (flags.flows) {
+    if (components.flows) {
         await loadFlows(source);
     }
-    if (flags.settings) {
+    if (components.settings) {
         await loadSettings(source);
         await loadTranslations(source);
         await loadPresets(source);
     }
-    if (flags.extensions) {
+    if (components.extensions) {
         await loadExtensions(source);
     }
     return {};

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

@@ -1,6 +1,7 @@
+import { type TemplatePlan } from '../template-plan/index.js';
 /**
  * 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>;
+export default function loadCollections(dir: string, plan?: TemplatePlan): Promise<void>;

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

@@ -1,7 +1,8 @@
-import { createCollection, createField, readCollections, readFields, updateCollection, } from '@directus/sdk';
+import { createCollection, createField, readCollections, 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 readFile from '../utils/read-file.js';
 /**
@@ -9,12 +10,11 @@ import readFile from '../utils/read-file.js';
  * @param dir - The directory to read the collections and fields from
  * @returns {Promise<void>} - Returns nothing
  */
-export default async function loadCollections(dir) {
-    const collectionsToAdd = readFile('collections', dir);
-    const fieldsToAdd = readFile('fields', dir);
+export default async function loadCollections(dir, plan) {
+    const collectionsToAdd = readFile('collections', dir).filter((collection) => includesSchemaCollection(collection.collection, plan));
+    const fieldsToAdd = readFile('fields', dir).filter((field) => includesSchemaCollection(field.collection, plan));
     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);
     ux.action.stop();
 }
@@ -24,10 +24,12 @@ async function processCollections(collectionsToAdd, fieldsToAdd) {
     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));
+            await (existingCollection
+                ? addNewFieldsToExistingCollection(collection.collection, fieldsToAdd, existingFields)
+                : addNewCollectionWithFields(collection, fieldsToAdd));
         }
         catch (error) {
-            catchError(error);
+            catchError(error, { context: { collection: collection.collection } });
         }
     }
 }
@@ -44,8 +46,9 @@ const removeRequiredorIsNullable = (field) => {
     return field;
 };
 async function addNewCollectionWithFields(collection, allFields) {
-    const collectionFields = allFields.filter(field => field.collection === collection.collection)
-        .map(field => removeRequiredorIsNullable(field));
+    const collectionFields = allFields
+        .filter((field) => field.collection === collection.collection)
+        .map((field) => removeRequiredorIsNullable(field));
     const collectionWithoutGroup = {
         ...collection,
         fields: collectionFields,
@@ -55,8 +58,9 @@ async function addNewCollectionWithFields(collection, allFields) {
     await api.client.request(createCollection(collectionWithoutGroup));
 }
 async function addNewFieldsToExistingCollection(collectionName, fieldsToAdd, existingFields) {
-    const collectionFieldsToAdd = fieldsToAdd.filter(field => field.collection === collectionName)
-        .map(field => removeRequiredorIsNullable(field));
+    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)) {
@@ -65,28 +69,11 @@ async function addNewFieldsToExistingCollection(collectionName, fieldsToAdd, exi
                 await api.client.request(createField(collectionName, field));
             }
             catch (error) {
-                catchError(error);
+                catchError(error, { context: { collection: collectionName, field: field.field } });
             }
         }
     }
 }
-async function updateCollections(collections) {
-    for await (const collection of collections) {
-        try {
-            if (collection.meta.group) {
-                const pl = {
-                    meta: {
-                        group: collection.meta.group,
-                    },
-                };
-                await api.client.request(updateCollection(collection.collection, pl));
-            }
-        }
-        catch (error) {
-            catchError(error);
-        }
-    }
-}
 async function addCustomFieldsOnSystemCollections(fields) {
     const customFields = fields.filter((field) => field.collection.startsWith('directus_'));
     const existingFields = await api.client.request(readFields());
@@ -99,7 +86,7 @@ async function addCustomFieldsOnSystemCollections(fields) {
             }
         }
         catch (error) {
-            catchError(error);
+            catchError(error, { context: { collection: field.collection, field: field.field } });
         }
     }
 }

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

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

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

@@ -1,28 +1,50 @@
 import { createItems, readItems, updateItemsBatch, updateSingleton } from '@directus/sdk';
 import { ux } from '@oclif/core';
+import fs from 'node:fs';
 import path from 'pathe';
 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 { chunkArray } from '../utils/chunk-array.js';
 import readFile from '../utils/read-file.js';
 const BATCH_SIZE = 50;
-export default async function loadData(dir) {
-    const collections = readFile('collections', dir);
+export default async function loadData(dir, plan) {
+    const collections = getUserCollections(dir, plan);
     ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading data for ${collections.length} collections`));
-    await loadSkeletonRecords(dir);
-    await loadFullData(dir);
-    await loadSingletons(dir);
+    await loadSkeletonRecords(dir, plan);
+    await loadFullData(dir, plan);
+    await loadSingletons(dir, plan);
     ux.action.stop();
 }
-async function loadSkeletonRecords(dir) {
-    ux.action.status = 'Loading skeleton records';
+function getContentCollections(dir) {
+    const contentDir = path.resolve(dir, 'content');
+    if (!fs.existsSync(contentDir))
+        return new Set();
+    return new Set(fs
+        .readdirSync(contentDir)
+        .filter((file) => file.endsWith('.json'))
+        .map((file) => path.basename(file, '.json')));
+}
+function getUserCollections(dir, plan) {
+    const contentCollections = getContentCollections(dir);
     const collections = readFile('collections', dir);
+    const relations = plan?.partial ? readFile('relations', dir) : [];
+    const brokenJunctions = getBrokenJunctionCollections(relations, plan);
+    if (brokenJunctions.size > 0) {
+        ux.warn(`Skipping junction collections with excluded FK targets: ${[...brokenJunctions].join(', ')}`);
+    }
+    return collections
+        .filter((item) => contentCollections.has(item.collection))
+        .filter((item) => !item.collection.startsWith('directus_', 0))
+        .filter((item) => item.schema !== null)
+        .filter((item) => includesCollection(item.collection, plan))
+        .filter((item) => !brokenJunctions.has(item.collection));
+}
+async function loadSkeletonRecords(dir, plan) {
+    ux.action.status = 'Loading skeleton records';
     const primaryKeyMap = await getCollectionPrimaryKeys(dir);
-    const userCollections = collections
-        .filter(item => !item.collection.startsWith('directus_', 0))
-        .filter(item => item.schema !== null)
-        .filter(item => !item.meta.singleton);
+    const userCollections = getUserCollections(dir, plan).filter((item) => !item.meta.singleton);
     await Promise.all(userCollections.map(async (collection) => {
         const name = collection.collection;
         const primaryKeyField = getPrimaryKey(primaryKeyMap, name);
@@ -31,14 +53,11 @@ async function loadSkeletonRecords(dir) {
         // 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.stdout(`${ux.colorize('dim', '--')} Skipping ${name}: No new records to add`)
+        const newData = data.filter((entry) => !existingPrimaryKeys.has(entry[primaryKeyField]));
+        if (newData.length === 0)
             return;
-        }
-        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}`)
+        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.action.status = 'Loaded skeleton records';
 }
@@ -63,7 +82,7 @@ async function getExistingPrimaryKeys(collection, primaryKeyField) {
             page++;
         }
         catch (error) {
-            catchError(error);
+            catchError(error, { context: { collection, page } });
             break;
         }
     }
@@ -74,31 +93,24 @@ async function uploadBatch(collection, batch, method) {
         await api.client.request(method(collection, batch));
     }
     catch (error) {
-        catchError(error);
+        catchError(error, { context: { batchSize: batch.length, collection } });
     }
 }
-async function loadFullData(dir) {
+async function loadFullData(dir, plan) {
     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);
+    const userCollections = getUserCollections(dir, plan).filter((item) => !item.meta.singleton);
     await Promise.all(userCollections.map(async (collection) => {
         const name = collection.collection;
         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)));
+        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)));
     }));
     ux.action.status = 'Updated records with full data';
 }
-async function loadSingletons(dir) {
+async function loadSingletons(dir, plan) {
     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);
+    const singletonCollections = getUserCollections(dir, plan).filter((item) => item.meta.singleton);
     await Promise.all(singletonCollections.map(async (collection) => {
         const name = collection.collection;
         const sourceDir = path.resolve(dir, 'content');
@@ -108,7 +120,7 @@ async function loadSingletons(dir) {
             await api.client.request(updateSingleton(name, cleanedData));
         }
         catch (error) {
-            catchError(error);
+            catchError(error, { context: { collection: name } });
         }
     }));
     ux.action.status = 'Loaded data for singleton collections';

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

@@ -1,6 +1,6 @@
 import { readFiles, uploadFiles } from '@directus/sdk';
 import { ux } from '@oclif/core';
-import { FormData } from 'formdata-node';
+import { File } from 'node:buffer';
 import { readFileSync } from 'node:fs';
 import path from 'pathe';
 import { DIRECTUS_PINK } from '../constants.js';
@@ -17,9 +17,9 @@ export default async function loadFiles(dir) {
                 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 => {
+            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;
                 }
@@ -31,7 +31,8 @@ export default async function loadFiles(dir) {
             await Promise.all(filesToUpload.map(async (asset) => {
                 const fileName = asset.filename_disk;
                 const assetPath = path.resolve(dir, 'assets', fileName);
-                const fileStream = new Blob([readFileSync(assetPath)], { type: asset.type });
+                const mimeType = asset.type || 'application/octet-stream';
+                const file = new File([readFileSync(assetPath)], fileName, { type: mimeType });
                 const form = new FormData();
                 form.append('id', asset.id);
                 if (asset.title)
@@ -40,9 +41,8 @@ export default async function loadFiles(dir) {
                     form.append('description', asset.description);
                 if (asset.folder)
                     form.append('folder', asset.folder);
-                if (asset.type)
-                    form.append('type', asset.type);
-                form.append('file', fileStream, fileName);
+                form.append('type', mimeType);
+                form.append('file', file);
                 try {
                     await api.client.request(uploadFiles(form));
                 }

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

@@ -1,6 +1,7 @@
+import { type TemplatePlan } from '../template-plan/index.js';
 /**
  * Load relationships into the Directus instance
  * @param dir - The directory to read the relations from
  * @returns {Promise<void>} - Returns nothing
  */
-export default function loadRelations(dir: string): Promise<void>;
+export default function loadRelations(dir: string, plan?: TemplatePlan): Promise<void>;

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

@@ -2,6 +2,7 @@ import { createRelation, readRelations } from '@directus/sdk';
 import { ux } from '@oclif/core';
 import { DIRECTUS_PINK } from '../constants.js';
 import { api } from '../sdk.js';
+import { includesRelation } from '../template-plan/index.js';
 import catchError from '../utils/catch-error.js';
 import readFile from '../utils/read-file.js';
 /**
@@ -9,20 +10,22 @@ import readFile from '../utils/read-file.js';
  * @param dir - The directory to read the relations from
  * @returns {Promise<void>} - Returns nothing
  */
-export default async function loadRelations(dir) {
-    const relations = readFile('relations', dir);
+export default async function loadRelations(dir, plan) {
+    const relations = readFile('relations', dir).filter((relation) => includesRelation(relation.collection, relation.related_collection, plan));
     ux.action.start(ux.colorize(DIRECTUS_PINK, `Loading ${relations.length} relations`));
     if (relations && relations.length > 0) {
         // Fetch existing relations
         const existingRelations = await api.client.request(readRelations());
-        const existingRelationKeys = new Set(existingRelations.map(relation => `${relation.collection}:${relation.field}:${relation.related_collection}`));
-        const relationsToAdd = relations.filter(relation => {
+        const existingRelationKeys = new Set(existingRelations.map((relation) => `${relation.collection}:${relation.field}:${relation.related_collection}`));
+        const relationsToAdd = relations
+            .filter((relation) => {
             const key = `${relation.collection}:${relation.field}:${relation.related_collection}`;
             if (existingRelationKeys.has(key)) {
                 return false;
             }
             return true;
-        }).map(relation => {
+        })
+            .map((relation) => {
             const cleanRelation = { ...relation };
             cleanRelation.meta.id = undefined;
             return cleanRelation;
@@ -32,12 +35,19 @@ export default async function loadRelations(dir) {
     ux.action.stop();
 }
 async function addRelations(relations) {
-    for await (const relation of relations) {
+    for (const relation of relations) {
         try {
+            // eslint-disable-next-line no-await-in-loop
             await api.client.request(createRelation(relation));
         }
         catch (error) {
-            catchError(error);
+            catchError(error, {
+                context: {
+                    collection: relation.collection,
+                    field: relation.field,
+                    related: relation.related_collection,
+                },
+            });
         }
     }
 }

package/dist/lib/template-plan/collections.d.ts

@@ -0,0 +1,4 @@
+import type { TemplatePlan } from './types.js';
+export declare function includesCollection(collection: string, plan?: TemplatePlan): boolean;
+export declare function includesSchemaCollection(collection: string, plan?: TemplatePlan): boolean;
+export declare function includesRelation(collection: string, relatedCollection?: null | string, plan?: TemplatePlan): boolean;

package/dist/lib/template-plan/collections.js

@@ -0,0 +1,26 @@
+export function includesCollection(collection, plan) {
+    if (plan?.collections && !plan.collections.includes(collection))
+        return false;
+    if (plan?.excludeCollections?.includes(collection))
+        return false;
+    return true;
+}
+export function includesSchemaCollection(collection, plan) {
+    const schemaCollections = plan?.schemaCollections || plan?.collections;
+    if (schemaCollections && !schemaCollections.includes(collection))
+        return false;
+    if (plan?.excludeCollections?.includes(collection))
+        return false;
+    return true;
+}
+export function includesRelation(collection, relatedCollection, plan) {
+    if (!includesSchemaCollection(collection, plan))
+        return false;
+    if (!relatedCollection)
+        return true;
+    if (plan?.excludeCollections?.includes(relatedCollection))
+        return plan.relationStrategy === 'preserve';
+    if (relatedCollection.startsWith('directus_'))
+        return true;
+    return includesSchemaCollection(relatedCollection, plan);
+}

package/dist/lib/template-plan/flags.d.ts

@@ -0,0 +1,18 @@
+export declare const componentNames: readonly ["schema", "content", "files", "flows", "dashboards", "permissions", "settings", "extensions", "users"];
+export declare const partial: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+export declare const componentFlags: {
+    content: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    dashboards: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    extensions: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    files: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    flows: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    permissions: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    schema: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    settings: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    users: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};
+export declare const collections: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+export declare const excludeCollections: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+export declare const relationStrategy: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+export declare const allowBrokenRelations: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+export declare const noAssets: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/lib/template-plan/flags.js

@@ -0,0 +1,61 @@
+import { Flags } from '@oclif/core';
+export const componentNames = [
+    'schema',
+    'content',
+    'files',
+    'flows',
+    'dashboards',
+    'permissions',
+    'settings',
+    'extensions',
+    'users',
+];
+export const partial = Flags.boolean({
+    description: 'Enable partial template mode',
+    summary: 'Enable partial template mode',
+});
+export const componentFlags = {
+    content: Flags.boolean({ allowNo: true, default: undefined, description: 'Include content/data' }),
+    dashboards: Flags.boolean({ allowNo: true, default: undefined, description: 'Include dashboards and panels' }),
+    extensions: Flags.boolean({ allowNo: true, default: undefined, description: 'Include extensions' }),
+    files: Flags.boolean({ allowNo: true, default: undefined, description: 'Include files, folders, and assets' }),
+    flows: Flags.boolean({ allowNo: true, default: undefined, description: 'Include flows and operations' }),
+    permissions: Flags.boolean({
+        allowNo: true,
+        default: undefined,
+        description: 'Include permissions, roles, policies, and access',
+    }),
+    schema: Flags.boolean({
+        allowNo: true,
+        default: undefined,
+        description: 'Include schema, collections, fields, and relations',
+    }),
+    settings: Flags.boolean({
+        allowNo: true,
+        default: undefined,
+        description: 'Include settings, translations, and presets',
+    }),
+    users: Flags.boolean({ allowNo: true, default: undefined, description: 'Include users' }),
+};
+export const collections = Flags.string({
+    description: 'Only include these comma-separated collections',
+});
+export const excludeCollections = Flags.string({
+    aliases: ['exclude-collections'],
+    description: 'Exclude these comma-separated collections',
+});
+export const relationStrategy = Flags.string({
+    aliases: ['relation-strategy'],
+    description: 'How to handle relations to omitted data',
+    options: ['empty', 'preserve', 'deep'],
+});
+export const allowBrokenRelations = Flags.boolean({
+    aliases: ['allow-broken-relations'],
+    default: false,
+    description: 'Allow intentionally incomplete relation references',
+});
+export const noAssets = Flags.boolean({
+    aliases: ['no-assets'],
+    default: undefined,
+    description: 'Shorthand for --no-files and --exclude-collections directus_files',
+});

package/dist/lib/template-plan/index.d.ts

@@ -0,0 +1,16 @@
+import type { TemplateComponent, TemplatePlan } from './types.js';
+type BuildFlags = Partial<Record<TemplateComponent, boolean>> & {
+    allowBrokenRelations?: boolean;
+    collections?: string | string[];
+    excludeCollections?: string | string[];
+    noAssets?: boolean;
+    partial?: boolean;
+    relationStrategy?: string;
+};
+export declare function buildTemplatePlan(flags?: BuildFlags): TemplatePlan;
+export * from './collections.js';
+export * from './flags.js';
+export * from './junctions.js';
+export * from './metadata-plan.js';
+export * from './metadata.js';
+export * from './types.js';