directus-template-cli 0.7.8 → 0.8.0

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

@@ -1,28 +1,51 @@
 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')));
+}
+export function getUserCollections(dir, plan) {
+    const contentCollections = getContentCollections(dir);
     const collections = readFile('collections', dir);
+    const relationsPath = path.join(dir, 'relations.json');
+    const relations = plan?.partial && fs.existsSync(relationsPath) ? 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 +54,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 +83,7 @@ async function getExistingPrimaryKeys(collection, primaryKeyField) {
             page++;
         }
         catch (error) {
-            catchError(error);
+            catchError(error, { context: { collection, page } });
             break;
         }
     }
@@ -74,31 +94,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 +121,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-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';

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

@@ -0,0 +1,77 @@
+import catchError from '../utils/catch-error.js';
+import { componentNames } from './flags.js';
+function parseList(value) {
+    if (!value)
+        return undefined;
+    const raw = Array.isArray(value) ? value.join(',') : value;
+    const values = raw
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return values.length > 0 ? values : undefined;
+}
+function hasPartialOnlyFlags(flags) {
+    return Boolean(flags.collections ||
+        flags.excludeCollections ||
+        flags.noAssets === true ||
+        flags.relationStrategy !== undefined ||
+        flags.allowBrokenRelations === true);
+}
+function hasScopingFlags(flags) {
+    return Boolean(flags.collections || flags.excludeCollections || flags.noAssets === true || hasComponentFlags(flags));
+}
+function hasComponentFlags(flags) {
+    return componentNames.some((component) => flags[component] !== undefined);
+}
+function buildComponents(flags, partial) {
+    const components = {};
+    const enabled = componentNames.filter((component) => flags[component] === true);
+    const disabled = componentNames.filter((component) => flags[component] === false);
+    if (!partial) {
+        for (const component of componentNames)
+            components[component] = true;
+        return components;
+    }
+    if (enabled.length > 0) {
+        for (const component of componentNames)
+            components[component] = enabled.includes(component);
+    }
+    else if (disabled.length > 0) {
+        for (const component of componentNames)
+            components[component] = !disabled.includes(component);
+    }
+    else {
+        for (const component of componentNames)
+            components[component] = true;
+    }
+    if (flags.noAssets)
+        components.files = false;
+    return components;
+}
+export function buildTemplatePlan(flags = {}) {
+    const collections = parseList(flags.collections);
+    const excludeCollections = parseList(flags.excludeCollections) || (flags.noAssets ? [] : undefined);
+    if (flags.noAssets && !excludeCollections?.includes('directus_files')) {
+        excludeCollections?.push('directus_files');
+    }
+    const partial = Boolean(flags.partial || hasComponentFlags(flags) || hasPartialOnlyFlags(flags));
+    const components = buildComponents(flags, partial);
+    if (!componentNames.some((component) => components[component])) {
+        catchError(new Error('At least one template component must be enabled.'), { fatal: true });
+    }
+    return {
+        allowBrokenRelations: Boolean(flags.allowBrokenRelations),
+        collections,
+        components,
+        excludeCollections,
+        partial,
+        relationStrategy: (flags.relationStrategy ||
+            (partial ? (hasScopingFlags(flags) ? 'empty' : 'preserve') : 'deep')),
+    };
+}
+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';

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

@@ -0,0 +1,10 @@
+import type { TemplatePlan } from './types.js';
+interface JunctionRelation {
+    collection: string;
+    meta?: {
+        junction_field?: null | string;
+    };
+    related_collection?: null | string;
+}
+export declare function getBrokenJunctionCollections(relations: JunctionRelation[], plan?: TemplatePlan): Set<string>;
+export {};

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

@@ -0,0 +1,19 @@
+import { includesCollection } from './collections.js';
+// Directus sets meta.junction_field on both FK legs of an M2M to point to the other FK.
+// Any collection appearing as `collection` on such a relation is a junction table.
+// System collections (directus_*) always exist on every instance — never treat them as broken FK targets.
+export function getBrokenJunctionCollections(relations, plan) {
+    if (!plan?.partial)
+        return new Set();
+    const junctionCollections = new Set(relations.filter((r) => r.meta?.junction_field).map((r) => r.collection));
+    const broken = new Set();
+    for (const junction of junctionCollections) {
+        const targets = relations
+            .filter((r) => r.collection === junction && r.related_collection)
+            .map((r) => r.related_collection);
+        if (targets.some((target) => !target.startsWith('directus_') && !includesCollection(target, plan))) {
+            broken.add(junction);
+        }
+    }
+    return broken;
+}

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

@@ -0,0 +1,2 @@
+import type { TemplateMetadata, TemplatePlan } from './types.js';
+export declare function applyMetadataToPlan(plan: TemplatePlan, metadata?: TemplateMetadata): TemplatePlan;

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

@@ -0,0 +1,36 @@
+import catchError from '../utils/catch-error.js';
+import { componentNames } from './flags.js';
+function intersectCollections(scope, requested, available) {
+    if (requested && available) {
+        const collections = requested.filter((collection) => available.includes(collection));
+        if (collections.length === 0) {
+            catchError(new Error(`No requested ${scope} match this template`), { fatal: true });
+        }
+        return collections;
+    }
+    return requested || available;
+}
+function mergeExcludedCollections(requested, available) {
+    const values = [...(requested || []), ...(available || [])];
+    return values.length > 0 ? [...new Set(values)] : undefined;
+}
+export function applyMetadataToPlan(plan, metadata) {
+    if (!metadata)
+        return plan;
+    const components = { ...plan.components };
+    for (const component of componentNames) {
+        components[component] = components[component] && metadata.components[component];
+    }
+    const partial = plan.partial ||
+        metadata.partial ||
+        componentNames.some((component) => components[component] !== plan.components[component]);
+    return {
+        ...plan,
+        collections: intersectCollections('collections', plan.collections, metadata.collections),
+        components,
+        excludeCollections: mergeExcludedCollections(plan.excludeCollections, metadata.excludedCollections),
+        partial,
+        relationStrategy: metadata.relationStrategy ?? plan.relationStrategy,
+        schemaCollections: intersectCollections('schema collections', plan.schemaCollections, metadata.schemaCollections),
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { TemplateMetadata, TemplatePlan, TemplateWarning } from './types.js';
+export declare function createTemplateMetadata(plan: TemplatePlan, warnings?: TemplateWarning[]): TemplateMetadata;
+export declare function getTemplateMetadataPath(dir: string): string;
+export declare function readTemplateMetadata(dir: string): TemplateMetadata | undefined;
+export declare function writeTemplateMetadata(dir: string, plan: TemplatePlan, warnings?: TemplateWarning[]): Promise<void>;

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

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'pathe';
+import catchError from '../utils/catch-error.js';
+const META_FILE = 'template-meta.json';
+export function createTemplateMetadata(plan, warnings = []) {
+    return {
+        allowBrokenRelations: plan.allowBrokenRelations,
+        collections: plan.collections,
+        components: plan.components,
+        excludedCollections: plan.excludeCollections,
+        partial: plan.partial,
+        relationStrategy: plan.relationStrategy,
+        schemaCollections: plan.schemaCollections,
+        version: 2,
+        warnings,
+    };
+}
+export function getTemplateMetadataPath(dir) {
+    return path.join(dir, META_FILE);
+}
+export function readTemplateMetadata(dir) {
+    const filePath = getTemplateMetadataPath(dir);
+    if (!fs.existsSync(filePath))
+        return undefined;
+    let metadata;
+    try {
+        metadata = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        catchError(error, { fatal: true });
+        return undefined;
+    }
+    if (metadata.version !== 2) {
+        catchError(new Error(`Unsupported template metadata version: ${metadata.version}`), { fatal: true });
+        return undefined;
+    }
+    return metadata;
+}
+export async function writeTemplateMetadata(dir, plan, warnings = []) {
+    const filePath = getTemplateMetadataPath(dir);
+    await fs.promises.writeFile(filePath, JSON.stringify(createTemplateMetadata(plan, warnings), null, 2));
+}

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

@@ -0,0 +1,34 @@
+export type RelationStrategy = 'deep' | 'empty' | 'preserve';
+export interface TemplateComponents {
+    content: boolean;
+    dashboards: boolean;
+    extensions: boolean;
+    files: boolean;
+    flows: boolean;
+    permissions: boolean;
+    schema: boolean;
+    settings: boolean;
+    users: boolean;
+}
+export interface TemplatePlan {
+    allowBrokenRelations: boolean;
+    collections?: string[];
+    components: TemplateComponents;
+    excludeCollections?: string[];
+    partial: boolean;
+    relationStrategy: RelationStrategy;
+    schemaCollections?: string[];
+}
+export type TemplateWarning = {
+    collection: string;
+    count: number;
+    field: string;
+    relatedCollection: string;
+    type: 'excluded_relation';
+};
+export interface TemplateMetadata extends Omit<TemplatePlan, 'excludeCollections'> {
+    excludedCollections?: string[];
+    version: 2;
+    warnings: TemplateWarning[];
+}
+export type TemplateComponent = keyof TemplateComponents;

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

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