@researchdatabox/redbox-dev-tools 0.0.1 → 5.0.0-RC2

package/dist/commands/form-config.js

@@ -0,0 +1,401 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMigrateFormConfigCommand = registerMigrateFormConfigCommand;
+exports.registerMigrateDataClassificationCommand = registerMigrateDataClassificationCommand;
+exports.registerClientFormConfigCommand = registerClientFormConfigCommand;
+exports.registerQuestionTreeDiagramCommand = registerQuestionTreeDiagramCommand;
+exports.registerMigrateFigshareConfigCommand = registerMigrateFigshareConfigCommand;
+const fs_1 = __importDefault(require("fs"));
+const path = __importStar(require("path"));
+const redbox_core_1 = require("@researchdatabox/redbox-core");
+const migrationLogger = {
+    silly: (...args) => console.debug(...args),
+    verbose: (...args) => console.debug(...args),
+    trace: (...args) => console.debug(...args),
+    debug: (...args) => console.debug(...args),
+    log: (...args) => console.log(...args),
+    info: (...args) => console.info(...args),
+    warn: (...args) => console.warn(...args),
+    error: (...args) => console.error(...args),
+    crit: (...args) => console.error(...args),
+    fatal: (...args) => console.error(...args),
+    silent: () => undefined,
+    blank: () => undefined,
+};
+function registerMigrateFormConfigCommand(program) {
+    program
+        .command('migrate-form-config')
+        .description('Migrate a legacy v4 JS form config file to the v5 TS form framework format')
+        .requiredOption('-i, --input <path>', 'Path to the legacy v4 form config JS file')
+        .requiredOption('-o, --output <path>', 'Path to write the migrated v5 TypeScript config file')
+        .option('--format <name>', "The output format, either 'esm' or 'cjs'")
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const inputPath = path.resolve(options.input);
+            const outputPath = path.resolve(options.output);
+            const outputFormat = options.format || "esm";
+            console.log(`\n🛠️  Migrating form config to ${outputFormat} format: ${inputPath} -> ${outputPath}\n`);
+            const migrateVisitor = new redbox_core_1.MigrationV4ToV5FormConfigVisitor(migrationLogger);
+            const migrated = await (0, redbox_core_1.migrateFormConfigFile)(migrateVisitor, inputPath, outputFormat);
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Migration completed; no file written.');
+            }
+            else {
+                fs_1.default.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs_1.default.writeFileSync(outputPath, migrated.tsContent, 'utf8');
+                console.log(`✅ Wrote migrated form config: ${outputPath}`);
+            }
+            await (0, redbox_core_1.migrateFormConfigVerify)(migrated.migrated, migrationLogger);
+            console.log('\n✅ Done!\n');
+        }
+        catch (error) {
+            console.error(`\n❌ Error: `, error);
+            process.exit(1);
+        }
+    });
+}
+function registerMigrateDataClassificationCommand(program) {
+    program
+        .command('migrate-data-classification')
+        .description('Migrate a legacy v4 JS data classification definition file to the v5 TS form framework format')
+        .requiredOption('-i, --input <path>', 'Path to the legacy v4 JS data classification definition file')
+        .requiredOption('-o, --output <path>', 'Path to write the migrated v5 TypeScript question tree config file')
+        .option('--format <name>', "The output format, either 'esm' or 'cjs'")
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const inputPath = path.resolve(options.input);
+            const outputPath = path.resolve(options.output);
+            const outputFormat = options.format || 'esm';
+            console.log(`\n🛠️  Migrating data classification to question tree to ${outputFormat} format: ${inputPath} -> ${outputPath}\n`);
+            const migrateVisitor = new redbox_core_1.MigrationV4ToV5FormConfigVisitor(migrationLogger);
+            const migrated = (0, redbox_core_1.migrateDataClassification)(migrateVisitor, inputPath, outputFormat);
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Migration completed; no file written.');
+            }
+            else {
+                fs_1.default.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs_1.default.writeFileSync(outputPath, migrated.tsContent, 'utf8');
+                console.log(`✅ Wrote migrated question tree config: ${outputPath}`);
+            }
+            await (0, redbox_core_1.migrateFormConfigVerify)(migrated.formConfig, migrationLogger);
+            console.log('\n✅ Done!\n');
+        }
+        catch (error) {
+            console.error(`\n❌ Error: `, error);
+            process.exit(1);
+        }
+    });
+}
+function registerClientFormConfigCommand(program) {
+    program
+        .command('client-form-config')
+        .description('Process a form config to produce the client form config')
+        .requiredOption('-i, --input <path>', 'Path to read the server-side form config TypeScript file')
+        .requiredOption('-o, --output <path>', 'Path to write the client-side form config TypeScript file')
+        .option('--formMode <name>', "The form mode, either 'edit' or 'view'")
+        .option('--userRoles <name...>', "The user roles, zero or more of 'Admin', 'Librarians', 'Researcher', 'Guest'")
+        .option('-r, --record <path>', "Path to read the data record file")
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const inputPath = path.resolve(options.input);
+            const outputPath = path.resolve(options.output);
+            const formMode = options.formMode ?? null;
+            const userRoles = options.userRoles ?? null;
+            const record = options.record ? require(path.resolve(options.record)) : null;
+            console.log(`\n🛠️  Building client form config from server form config: ${inputPath} -> ${outputPath}\n`);
+            const serverFormConfig = require(inputPath).default;
+            const clientFormConfig = await (0, redbox_core_1.createClientFormConfig)(serverFormConfig, migrationLogger, formMode, userRoles, undefined, record);
+            const tsContent = `import { FormConfigFrame } from '@researchdatabox/sails-ng-common';
+const clientFormConfig: FormConfigFrame = ${JSON.stringify(clientFormConfig, null, 2)};
+export default clientFormConfig;`;
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Client form config built from server form config; no file written.');
+            }
+            else {
+                fs_1.default.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs_1.default.writeFileSync(outputPath, tsContent, 'utf8');
+                console.log(`✅ Wrote client form config: ${outputPath}`);
+            }
+            await (0, redbox_core_1.migrateFormConfigVerify)(clientFormConfig, migrationLogger);
+            console.log('\n✅ Done!\n');
+        }
+        catch (error) {
+            console.error(`\n❌ Error: `, error);
+            process.exit(1);
+        }
+    });
+}
+function registerQuestionTreeDiagramCommand(program) {
+    program
+        .command('question-tree-diagram')
+        .description('Convert a question tree config to a mermaid diagram text file')
+        .requiredOption('-i, --input <path>', 'Path to read the question tree form config TypeScript file')
+        .requiredOption('-o, --output <path>', 'Path to write the diagram text file')
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const inputPath = path.resolve(options.input);
+            const outputPath = path.resolve(options.output);
+            console.log(`\n🛠️  Creating diagram from form config: ${inputPath} -> ${outputPath}\n`);
+            const componentConfig = require(inputPath);
+            const diagram = await (0, redbox_core_1.createQuestionTreeDiagram)(componentConfig, migrationLogger);
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Built diagram from form config; no file written.');
+            }
+            else {
+                fs_1.default.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs_1.default.writeFileSync(outputPath, diagram, 'utf8');
+                console.log(`✅ Wrote diagram text file: ${outputPath}`);
+            }
+        }
+        catch (error) {
+            console.error(`\n❌ Error: `, error);
+            process.exit(1);
+        }
+    });
+}
+function collectLegacyTemplates(value, pathPrefix = '') {
+    if (typeof value === 'string') {
+        return value.includes('<%') ? [pathPrefix] : [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((entry, index) => collectLegacyTemplates(entry, `${pathPrefix}[${index}]`));
+    }
+    if (value && typeof value === 'object') {
+        return Object.entries(value).flatMap(([key, entry]) => collectLegacyTemplates(entry, pathPrefix ? `${pathPrefix}.${key}` : key));
+    }
+    return [];
+}
+function loadLegacyModule(modulePath) {
+    const resolvedPath = path.resolve(modulePath);
+    const loaded = require(resolvedPath);
+    if (loaded == null || typeof loaded !== 'object') {
+        throw new Error(`Legacy config module '${resolvedPath}' did not export an object`);
+    }
+    return loaded;
+}
+function pickLegacyExport(moduleExports, exportName) {
+    const named = moduleExports[exportName];
+    if (named != null && typeof named === 'object') {
+        return named;
+    }
+    return moduleExports;
+}
+function toNumericStatusCodes(value) {
+    if (!Array.isArray(value)) {
+        return [408, 429, 500, 502, 503, 504];
+    }
+    return value
+        .map((entry) => Number(entry))
+        .filter((entry) => Number.isFinite(entry));
+}
+function createMigratedFigsharePublishingConfig(brand, figshareApi, figshareApiEnv = {}, figshareForMapping = {}) {
+    const overrideArtifacts = figshareApiEnv.overrideArtifacts ?? {};
+    const mapping = {
+        ...(figshareApi.mapping ?? {}),
+        ...(overrideArtifacts.mapping ?? {})
+    };
+    const resolvedBaseUrl = String(overrideArtifacts.baseURL ?? figshareApi.baseURL ?? '');
+    const resolvedFrontEndUrl = String(overrideArtifacts.frontEndURL ?? figshareApi.frontEndURL ?? '');
+    const resolvedToken = String(overrideArtifacts.APIToken ?? figshareApi.APIToken ?? '');
+    return {
+        enabled: Boolean(resolvedToken && resolvedBaseUrl && resolvedFrontEndUrl),
+        connection: {
+            baseUrl: resolvedBaseUrl,
+            frontEndUrl: resolvedFrontEndUrl,
+            token: resolvedToken,
+            timeoutMs: 30000,
+            operationTimeouts: {
+                metadataMs: 30000,
+                uploadInitMs: 30000,
+                uploadPartMs: 120000,
+                publishMs: 60000
+            },
+            retry: {
+                maxAttempts: Number(figshareApi.retry?.maxAttempts ?? 3),
+                baseDelayMs: Number(figshareApi.retry?.baseDelayMs ?? 500),
+                maxDelayMs: Number(figshareApi.retry?.maxDelayMs ?? 4000),
+                retryOnStatusCodes: toNumericStatusCodes(figshareApi.retry?.retryOnStatusCodes),
+                retryOnMethods: ['get', 'put', 'delete']
+            }
+        },
+        article: {
+            itemType: mapping.figshareItemType ?? 'dataset',
+            groupId: mapping.figshareItemGroupId,
+            publishMode: mapping.figshareNeedsPublishAfterFileUpload ? 'afterUploadsComplete' : 'immediate',
+            republishOnMetadataChange: true,
+            republishOnAssetChange: true
+        },
+        record: {
+            articleIdPath: mapping.recordFigArticleId ?? 'metadata.figshare_article_id',
+            dataLocationsPath: mapping.recordDataLocations ?? 'metadata.dataLocations',
+            statusPath: 'metadata.figshareStatus',
+            errorPath: 'metadata.figshareError',
+            syncStatePath: 'metadata.figshareSyncState',
+            allFilesUploadedPath: typeof mapping.recordAllFilesUploaded === 'string' ? mapping.recordAllFilesUploaded : ''
+        },
+        selection: {
+            attachmentMode: mapping.figshareOnlyPublishSelectedAttachmentFiles ? 'selectedOnly' : 'all',
+            urlMode: mapping.figshareOnlyPublishSelectedLocationURLs ? 'selectedOnly' : 'all',
+            selectedFlagPath: 'selected'
+        },
+        authors: {
+            uniqueBy: mapping.recordAuthorUniqueBy ?? 'email',
+            externalNameField: mapping.recordAuthorExternalName ?? 'text_full_name',
+            maxInlineAuthors: 50,
+            contributorPaths: ['metadata.contributor_ci', 'metadata.contributors'],
+            lookup: []
+        },
+        metadata: {
+            title: { kind: 'path', path: 'metadata.title' },
+            description: { kind: 'path', path: 'metadata.description' },
+            keywords: { kind: 'path', path: 'metadata.finalKeywords', defaultValue: [] },
+            funding: { kind: 'path', path: 'metadata.funder' },
+            license: { source: { kind: 'path', path: mapping.recordLicensePath ?? 'metadata.license' }, matchBy: 'urlContains', required: true },
+            categories: { source: { kind: 'path', path: mapping.recordCategoryPath ?? 'metadata.forCodes', defaultValue: [] } },
+            customFields: []
+        },
+        categories: {
+            mappingTable: ((figshareForMapping.FORMapping ?? []).map((entry) => ({
+                sourceCode: String(entry.redboxCode ?? entry.sourceCode ?? ''),
+                figshareCategoryId: Number(entry.figshareCategoryId ?? entry.figCode ?? 0)
+            }))).filter((entry) => entry.sourceCode !== ''),
+            allowUnmapped: false
+        },
+        assets: {
+            enableHostedFiles: true,
+            enableLinkFiles: true,
+            staging: {
+                cleanupPolicy: 'deleteAfterSuccess'
+            }
+        },
+        embargo: {
+            mode: 'recordDriven',
+            forceSync: Boolean(mapping.figshareForceEmbargoUpdateAlways),
+            accessRights: {
+                accessRights: { kind: 'path', path: 'metadata.accessRights' },
+                fullEmbargoUntil: { kind: 'path', path: 'metadata.embargoUntil' },
+                reason: { kind: 'path', path: 'metadata.embargoReason' }
+            }
+        },
+        queue: {
+            publishAfterUploadDelay: typeof mapping.schedulePublishAfterUploadJob === 'string' ? mapping.schedulePublishAfterUploadJob : 'in 2 minutes',
+            uploadedFilesCleanupDelay: typeof mapping.scheduleUploadedFilesCleanupJob === 'string' ? mapping.scheduleUploadedFilesCleanupJob : 'in 5 minutes'
+        },
+        workflow: {
+            transitionJob: {
+                enabled: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.enabled ?? 'false') === 'true',
+                namedQuery: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.namedQuery ?? ''),
+                targetStep: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.targetStep ?? ''),
+                paramMap: mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.paramMap ?? {},
+                figshareTargetFieldKey: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.figshareTargetFieldKey ?? ''),
+                figshareTargetFieldValue: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.figshareTargetFieldValue ?? ''),
+                username: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.username ?? ''),
+                userType: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.userType ?? '')
+            }
+        },
+        testing: {
+            mode: figshareApi.testMode ? 'fixture' : 'live'
+        },
+        writeBack: {
+            articleId: 'metadata.figshare_article_id',
+            // The legacy article URL paths are write targets, so they belong to writeBack.
+            articleUrls: Array.isArray(mapping.recordFigArticleURL)
+                ? mapping.recordFigArticleURL
+                : [typeof mapping.recordFigArticleURL === 'string' && mapping.recordFigArticleURL.trim() !== ''
+                        ? mapping.recordFigArticleURL
+                        : 'metadata.figshare_article_location'],
+            extraFields: []
+        },
+        migrationReport: {
+            brand,
+            unsupportedLegacyTemplates: collectLegacyTemplates(mapping)
+        }
+    };
+}
+function registerMigrateFigshareConfigCommand(program) {
+    program
+        .command('migrate-figshare-config')
+        .description('Migrate legacy Figshare config into figsharePublishing AppConfig JSON files')
+        .requiredOption('--figshare-api <path>', 'Path to the legacy figshareAPI config module')
+        .option('--figshare-api-env <path>', 'Path to the legacy figshareAPIEnv config module')
+        .option('--figshare-for-mapping <path>', 'Path to the legacy figshareReDBoxFORMapping config module')
+        .requiredOption('-o, --output <path>', 'Directory to write migrated figsharePublishing JSON files')
+        .option('-b, --brands <brands...>', 'Brands to generate config for', ['default'])
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const outputDir = path.resolve(options.output);
+            const brands = options.brands;
+            const figshareApi = pickLegacyExport(loadLegacyModule(options.figshareApi), 'figshareAPI');
+            const figshareApiEnv = options.figshareApiEnv
+                ? pickLegacyExport(loadLegacyModule(options.figshareApiEnv), 'figshareAPIEnv')
+                : {};
+            const figshareForMapping = options.figshareForMapping
+                ? pickLegacyExport(loadLegacyModule(options.figshareForMapping), 'figshareReDBoxFORMapping')
+                : {};
+            if (!globalOptions.dryRun) {
+                fs_1.default.mkdirSync(outputDir, { recursive: true });
+            }
+            const report = brands.map((brand) => {
+                const migrated = createMigratedFigsharePublishingConfig(brand, figshareApi, figshareApiEnv, figshareForMapping);
+                const outputPath = path.join(outputDir, `${brand}.figsharePublishing.json`);
+                if (!globalOptions.dryRun) {
+                    fs_1.default.writeFileSync(outputPath, JSON.stringify(migrated, null, 2) + '\n', 'utf8');
+                }
+                return {
+                    brand,
+                    outputPath,
+                    unsupportedLegacyTemplates: migrated.migrationReport.unsupportedLegacyTemplates
+                };
+            });
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Migration report generated; no files written.');
+            }
+            console.log(JSON.stringify(report, null, 2));
+        }
+        catch (error) {
+            console.error(`\n❌ Error: `, error);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/sync-translation.d.ts

@@ -0,0 +1,23 @@
+import { Command } from "commander";
+declare const contentFormats: readonly ["plain", "html"];
+type ContentFormats = typeof contentFormats[number];
+type MetaEntryKey = string;
+type MetaEntryValue = {
+    category?: string;
+    description?: string;
+    contentFormat?: ContentFormats;
+};
+export type MetaEntries = Record<MetaEntryKey, MetaEntryValue>;
+export type MetaData = {
+    source: string;
+    data: MetaEntries;
+};
+export type TranslationLocaleRaw = {
+    locale: string;
+    source: string;
+    data: Record<string, unknown>;
+};
+export type TranslationEntries = Record<string, string>;
+export type TranslationLocaleEntries = Record<string, TranslationEntries>;
+export declare function registerSyncTranslationCommand(program: Command): void;
+export {};