eventmodeler 0.5.0 → 0.6.0

package/dist/commands/update.js

@@ -0,0 +1,240 @@
+import { getGlobalId } from '../lib/globals';
+import { requireModelId } from '../lib/model';
+import { resolveAnyElement, unwrap, elementIdKey } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+const RENAME_FIELD_MAP = {
+    command: sdk.renameCommandField,
+    event: sdk.renameEventField,
+    readmodel: sdk.renameReadModelField,
+    screen: sdk.renameScreenField,
+    processor: sdk.renameProcessorField,
+    'external-event': sdk.renameExternalEventField,
+};
+const CHANGE_TYPE_MAP = {
+    command: sdk.changeCommandFieldType,
+    event: sdk.changeEventFieldType,
+    readmodel: sdk.changeReadModelFieldType,
+    screen: sdk.changeScreenFieldType,
+    processor: sdk.changeProcessorFieldType,
+    'external-event': sdk.changeExternalEventFieldType,
+};
+const REORDER_FIELD_MAP = {
+    command: sdk.reorderCommandField,
+    event: sdk.reorderEventField,
+    readmodel: sdk.reorderReadModelField,
+    screen: sdk.reorderScreenField,
+    processor: sdk.reorderProcessorField,
+    'external-event': sdk.reorderExternalEventField,
+};
+const RENAME_SUBFIELD_MAP = {
+    command: sdk.renameCommandSubfield,
+    event: sdk.renameEventSubfield,
+    readmodel: sdk.renameReadModelSubfield,
+    screen: sdk.renameScreenSubfield,
+    processor: sdk.renameProcessorSubfield,
+    'external-event': sdk.renameExternalEventSubfield,
+};
+const CHANGE_SUBFIELD_TYPE_MAP = {
+    command: sdk.changeCommandSubfieldType,
+    event: sdk.changeEventSubfieldType,
+    readmodel: sdk.changeReadModelSubfieldType,
+    screen: sdk.changeScreenSubfieldType,
+    processor: sdk.changeProcessorSubfieldType,
+    'external-event': sdk.changeExternalEventSubfieldType,
+};
+const REORDER_SUBFIELD_MAP = {
+    command: sdk.reorderCommandSubfield,
+    event: sdk.reorderEventSubfield,
+    readmodel: sdk.reorderReadModelSubfield,
+    screen: sdk.reorderScreenSubfield,
+    processor: sdk.reorderProcessorSubfield,
+    'external-event': sdk.reorderExternalEventSubfield,
+};
+const buildMarkMap = () => ({
+    command: {
+        optional: { mark: sdk.markCommandFieldAsOptional, unmark: sdk.unmarkCommandFieldAsOptional },
+        generated: { mark: sdk.markCommandFieldAsGenerated, unmark: sdk.unmarkCommandFieldAsGenerated },
+        list: { mark: sdk.markCommandFieldAsList, unmark: sdk.unmarkCommandFieldAsList },
+    },
+    event: {
+        optional: { mark: sdk.markEventFieldAsOptional, unmark: sdk.unmarkEventFieldAsOptional },
+        generated: { mark: sdk.markEventFieldAsGenerated, unmark: sdk.unmarkEventFieldAsGenerated },
+        list: { mark: sdk.markEventFieldAsList, unmark: sdk.unmarkEventFieldAsList },
+    },
+    readmodel: {
+        optional: { mark: sdk.markReadModelFieldAsOptional, unmark: sdk.unmarkReadModelFieldAsOptional },
+        generated: { mark: sdk.markReadModelFieldAsGenerated, unmark: sdk.unmarkReadModelFieldAsGenerated },
+        list: { mark: sdk.markReadModelFieldAsList, unmark: sdk.unmarkReadModelFieldAsList },
+    },
+    screen: {
+        optional: { mark: sdk.markScreenFieldAsOptional, unmark: sdk.unmarkScreenFieldAsOptional },
+        generated: { mark: sdk.markScreenFieldAsGenerated, unmark: sdk.unmarkScreenFieldAsGenerated },
+        list: { mark: sdk.markScreenFieldAsList, unmark: sdk.unmarkScreenFieldAsList },
+        'user-input': { mark: sdk.markScreenFieldAsUserInput, unmark: sdk.unmarkScreenFieldAsUserInput },
+    },
+    processor: {
+        optional: { mark: sdk.markProcessorFieldAsOptional, unmark: sdk.unmarkProcessorFieldAsOptional },
+        generated: { mark: sdk.markProcessorFieldAsGenerated, unmark: sdk.unmarkProcessorFieldAsGenerated },
+        list: { mark: sdk.markProcessorFieldAsList, unmark: sdk.unmarkProcessorFieldAsList },
+    },
+    'external-event': {
+        optional: { mark: sdk.markExternalEventFieldAsOptional, unmark: sdk.unmarkExternalEventFieldAsOptional },
+        list: { mark: sdk.markExternalEventFieldAsList, unmark: sdk.unmarkExternalEventFieldAsList },
+    },
+});
+const buildSubfieldMarkMap = () => ({
+    command: {
+        optional: { mark: sdk.markCommandSubfieldAsOptional, unmark: sdk.unmarkCommandSubfieldAsOptional },
+        generated: { mark: sdk.markCommandSubfieldAsGenerated, unmark: sdk.unmarkCommandSubfieldAsGenerated },
+        list: { mark: sdk.markCommandSubfieldAsList, unmark: sdk.unmarkCommandSubfieldAsList },
+    },
+    event: {
+        optional: { mark: sdk.markEventSubfieldAsOptional, unmark: sdk.unmarkEventSubfieldAsOptional },
+        generated: { mark: sdk.markEventSubfieldAsGenerated, unmark: sdk.unmarkEventSubfieldAsGenerated },
+        list: { mark: sdk.markEventSubfieldAsList, unmark: sdk.unmarkEventSubfieldAsList },
+    },
+    readmodel: {
+        optional: { mark: sdk.markReadModelSubfieldAsOptional, unmark: sdk.unmarkReadModelSubfieldAsOptional },
+        generated: { mark: sdk.markReadModelSubfieldAsGenerated, unmark: sdk.unmarkReadModelSubfieldAsGenerated },
+        list: { mark: sdk.markReadModelSubfieldAsList, unmark: sdk.unmarkReadModelSubfieldAsList },
+    },
+    screen: {
+        optional: { mark: sdk.markScreenSubfieldAsOptional, unmark: sdk.unmarkScreenSubfieldAsOptional },
+        generated: { mark: sdk.markScreenSubfieldAsGenerated, unmark: sdk.unmarkScreenSubfieldAsGenerated },
+        list: { mark: sdk.markScreenSubfieldAsList, unmark: sdk.unmarkScreenSubfieldAsList },
+        'user-input': { mark: sdk.markScreenSubfieldAsUserInput, unmark: sdk.unmarkScreenSubfieldAsUserInput },
+    },
+    processor: {
+        optional: { mark: sdk.markProcessorSubfieldAsOptional, unmark: sdk.unmarkProcessorSubfieldAsOptional },
+        generated: { mark: sdk.markProcessorSubfieldAsGenerated, unmark: sdk.unmarkProcessorSubfieldAsGenerated },
+        list: { mark: sdk.markProcessorSubfieldAsList, unmark: sdk.unmarkProcessorSubfieldAsList },
+    },
+    'external-event': {
+        optional: { mark: sdk.markExternalEventSubfieldAsOptional, unmark: sdk.unmarkExternalEventSubfieldAsOptional },
+        list: { mark: sdk.markExternalEventSubfieldAsList, unmark: sdk.unmarkExternalEventSubfieldAsList },
+    },
+});
+export function registerUpdateCommands(program) {
+    const update = program.command('update').description('Update fields and subfields');
+    update.command('field [elementName]')
+        .description('Update field properties')
+        .requiredOption('--field <name>', 'Field name')
+        .option('--name <newName>', 'Rename the field')
+        .option('--type <newType>', 'Change the field type')
+        .option('--optional <bool>', 'Mark as optional (true/false)')
+        .option('--generated <bool>', 'Mark as generated (true/false)')
+        .option('--list <bool>', 'Mark as list (true/false)')
+        .option('--user-input <bool>', 'Mark as user input (true/false, screens only)')
+        .action(async (elementName, opts, cmd) => {
+        const modelId = requireModelId();
+        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
+        const key = elementIdKey(elementType);
+        const fieldResult = unwrap(await sdk.resolveField({
+            query: { modelId, elementId, fieldName: opts.field }
+        }));
+        const fieldId = fieldResult.fieldId;
+        if (opts.name) {
+            const fn = RENAME_FIELD_MAP[elementType];
+            if (!fn)
+                throw new Error(`Cannot rename fields on type: ${elementType}`);
+            unwrap(await fn({ body: { modelId, [key]: elementId, fieldId, fieldName: opts.name } }));
+            console.log(`Renamed field to "${opts.name}".`);
+        }
+        if (opts.type) {
+            const fn = CHANGE_TYPE_MAP[elementType];
+            if (!fn)
+                throw new Error(`Cannot change field type on: ${elementType}`);
+            unwrap(await fn({ body: { modelId, [key]: elementId, fieldId, fieldType: opts.type } }));
+            console.log(`Changed field type to "${opts.type}".`);
+        }
+        const markMap = buildMarkMap();
+        for (const flag of ['optional', 'generated', 'list', 'user-input']) {
+            const value = opts[flag === 'user-input' ? 'userInput' : flag];
+            if (value === undefined)
+                continue;
+            const boolVal = value === 'true';
+            const entry = markMap[elementType]?.[flag];
+            if (!entry)
+                throw new Error(`Cannot set ${flag} on type: ${elementType}`);
+            const fn = boolVal ? entry.mark : entry.unmark;
+            unwrap(await fn({ body: { modelId, [key]: elementId, fieldId } }));
+            console.log(`${boolVal ? 'Marked' : 'Unmarked'} field as ${flag}.`);
+        }
+    });
+    // update subfield [elementName] --subfield <subfieldId> [--name <newName>] [--type <newType>] [--list <bool>] ...
+    update.command('subfield [elementName]')
+        .description('Update subfield properties')
+        .requiredOption('--subfield <id>', 'Subfield ID (from show output)')
+        .option('--name <newName>', 'Rename the subfield')
+        .option('--type <newType>', 'Change the subfield type')
+        .option('--optional <bool>', 'Mark as optional (true/false)')
+        .option('--generated <bool>', 'Mark as generated (true/false)')
+        .option('--list <bool>', 'Mark as list (true/false)')
+        .option('--user-input <bool>', 'Mark as user input (true/false, screens only)')
+        .action(async (elementName, opts, cmd) => {
+        const modelId = requireModelId();
+        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
+        const key = elementIdKey(elementType);
+        if (opts.name) {
+            const fn = RENAME_SUBFIELD_MAP[elementType];
+            if (!fn)
+                throw new Error(`Cannot rename subfields on type: ${elementType}`);
+            unwrap(await fn({ body: { modelId, [key]: elementId, subfieldId: opts.subfield, fieldName: opts.name } }));
+            console.log(`Renamed subfield to "${opts.name}".`);
+        }
+        if (opts.type) {
+            const fn = CHANGE_SUBFIELD_TYPE_MAP[elementType];
+            if (!fn)
+                throw new Error(`Cannot change subfield type on: ${elementType}`);
+            unwrap(await fn({ body: { modelId, [key]: elementId, subfieldId: opts.subfield, fieldType: opts.type } }));
+            console.log(`Changed subfield type to "${opts.type}".`);
+        }
+        const markMap = buildSubfieldMarkMap();
+        for (const flag of ['optional', 'generated', 'list', 'user-input']) {
+            const value = opts[flag === 'user-input' ? 'userInput' : flag];
+            if (value === undefined)
+                continue;
+            const boolVal = value === 'true';
+            const entry = markMap[elementType]?.[flag];
+            if (!entry)
+                throw new Error(`Cannot set ${flag} on type: ${elementType}`);
+            const fn = boolVal ? entry.mark : entry.unmark;
+            unwrap(await fn({ body: { modelId, [key]: elementId, subfieldId: opts.subfield } }));
+            console.log(`${boolVal ? 'Marked' : 'Unmarked'} subfield as ${flag}.`);
+        }
+    });
+    // update reorder [elementName] --field <name> --position <n>
+    update.command('reorder [elementName]')
+        .description('Reorder a field on an element')
+        .requiredOption('--field <name>', 'Field name')
+        .requiredOption('--position <n>', 'New position (0-based)', parseInt)
+        .action(async (elementName, opts, cmd) => {
+        const modelId = requireModelId();
+        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
+        const fn = REORDER_FIELD_MAP[elementType];
+        if (!fn)
+            throw new Error(`Cannot reorder fields on type: ${elementType}`);
+        const fieldResult = unwrap(await sdk.resolveField({
+            query: { modelId, elementId, fieldName: opts.field }
+        }));
+        const fieldId = fieldResult.fieldId;
+        const key = elementIdKey(elementType);
+        unwrap(await fn({ body: { modelId, [key]: elementId, fieldId, position: opts.position } }));
+        console.log(`Moved field "${opts.field}" to position ${opts.position}.`);
+    });
+    // update reorder-subfield [elementName] --subfield <id> --position <n>
+    update.command('reorder-subfield [elementName]')
+        .description('Reorder a subfield within its parent')
+        .requiredOption('--subfield <id>', 'Subfield ID (from show output)')
+        .requiredOption('--position <n>', 'New position (0-based)', parseInt)
+        .action(async (elementName, opts, cmd) => {
+        const modelId = requireModelId();
+        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
+        const fn = REORDER_SUBFIELD_MAP[elementType];
+        if (!fn)
+            throw new Error(`Cannot reorder subfields on type: ${elementType}`);
+        const key = elementIdKey(elementType);
+        unwrap(await fn({ body: { modelId, [key]: elementId, subfieldId: opts.subfield, position: opts.position } }));
+        console.log(`Moved subfield to position ${opts.position}.`);
+    });
+}